home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Graphics / Misc / NeXTcontour_1.7 / Source / Contour.m < prev    next >
Encoding:
Text File  |  1995-06-12  |  102.0 KB  |  3,854 lines
  1.  
  2. /* Generated by Interface Builder */
  3.  
  4. #import "defs.h"
  5. #import "Contour.h"
  6. #import <appkit/Button.h>
  7. #import <appkit/OpenPanel.h>
  8. #import <appkit/Matrix.h>
  9. #import <appkit/Cell.h>
  10. #import <appkit/Pasteboard.h>
  11. #import <appkit/Application.h>
  12. #import <appkit/NXColorWell.h>
  13. #import <appkit/color.h>
  14. #import <objc/Storage.h>
  15. #import <math.h>
  16. #import <strings.h>
  17. #import <defaults/defaults.h>
  18. #import <streams/streams.h>
  19. #import <sys/types.h>
  20. #import <sys/stat.h>
  21. #import "TextView.h"
  22.  
  23. @implementation Contour
  24.  
  25. /* Public methods */
  26.  
  27. + initialize
  28. /* Initializes the defaults. */
  29. {
  30.     const NXDefaultsVector NeXTcontourDefaults = {
  31.     { "Two_D", "NO" },
  32.         { "AeroDynamics", "YES"},
  33.         { "Binary_Data", "YES"},
  34.         { "number_Of_Functions_Read_In", "5"},
  35.         { "colorOption", "NO"},
  36.         { "printColorMode", "NO"},
  37.     { NULL, NULL }
  38.     };
  39.       
  40.     NXRegisterDefaults("NeXTcontour", NeXTcontourDefaults);
  41.  
  42.     return self;
  43.   }
  44.  
  45. + new
  46. {
  47.   const char *validSendTypes[2];
  48.  
  49.   self = [[super alloc] init];
  50.   openPanel  = [OpenPanel new];
  51.  
  52.   validSendTypes[0] = NXAsciiPboardType;
  53.   validSendTypes[1] = NULL;
  54.   [NXApp registerServicesMenuSendTypes:validSendTypes andReturnTypes:NULL];
  55.   [NXApp setDelegate:self];
  56.   return self;
  57. }
  58.  
  59. - appWillInit:sender
  60. {
  61.  
  62.   /*  get default parameters and reset buttons */
  63.  
  64.   NXUpdateDefaults();
  65.  
  66.   /* Initialize defaults */
  67.   Two_D = strncmp(NXGetDefaultValue("NeXTcontour", "Two_D"),"YES",3)==0 ?
  68.   YES: NO;
  69.  
  70.   number_Of_Functions_Read_In = 
  71.     strncmp(NXGetDefaultValue("NeXTcontour", "number_Of_Functions_Read_In"),
  72.         "4",3) ==0 ? 4: 1;
  73.  
  74.   colorOption = strncmp(NXGetDefaultValue("NeXTcontour", "colorOption"),
  75.             "YES",3)==0 ? YES: NO;
  76.  
  77.   printColorMode = 
  78.     strncmp(NXGetDefaultValue("NeXTcontour", "printColorMode"),
  79.         "YES",3)==0 ? YES: NO;
  80.  
  81.   AeroDynamic_Functions = 
  82.     strncmp(NXGetDefaultValue("NeXTcontour", "AeroDynamics"),
  83.             "YES",3)==0 ? YES: NO;
  84.  
  85.   Binary_Data_Type = 
  86.     strncmp(NXGetDefaultValue("NeXTcontour", "Binary_Data"),
  87.             "YES",3)==0 ? YES: NO;
  88.  
  89.   if(Two_D){
  90.     [choose2D3DData setState:1];
  91.     [choose2D3DGrid setState:1];
  92.     [setDefault2D3D  setState:1];
  93.     if(AeroDynamic_Functions){
  94.       [setDefaultNumberOfFunctions setIntValue:4 at:0];
  95.       [numberOfFunctions setIntValue:4 at:0];
  96.       number_Of_Functions_Read_In = 4;
  97.     }
  98.   }
  99.  
  100.   if(!Two_D){
  101.     [choose2D3DData setState:0];
  102.     [choose2D3DGrid setState:0];
  103.     [setDefault2D3D  setState:0];
  104.     if(AeroDynamic_Functions){
  105.       [setDefaultNumberOfFunctions setIntValue:5 at:0];
  106.       [numberOfFunctions setIntValue:5 at:0];
  107.       number_Of_Functions_Read_In = 5;
  108.     }
  109.   }
  110.  
  111.   if(AeroDynamic_Functions){
  112.     [chooseDiscipline setState:0];
  113.     [setDefaultDiscipline setState:0];
  114.   }
  115.  
  116.   if(!AeroDynamic_Functions){
  117.     [chooseDiscipline setState:1];
  118.     [setDefaultDiscipline setState:1];
  119.     [setDefaultNumberOfFunctions setIntValue:number_Of_Functions_Read_In at:0];
  120.     [numberOfFunctions setIntValue:number_Of_Functions_Read_In at:0];
  121.   }
  122.  
  123.   if(Binary_Data_Type){
  124.     [chooseDataType setState:0];
  125.     [setDefaultDataForm setState:0];
  126.   }
  127.  
  128.   if(!Binary_Data_Type){
  129.     [chooseDataType setState:1];
  130.     [setDefaultDataForm setState:1];
  131.   }
  132.  
  133.   if(colorOption){
  134.     [setDefaultColor setState:0];
  135.     [contourLineColor selectCellAt:0:3];
  136.   }
  137.   if(!colorOption){
  138.     [setDefaultColor setState:1];
  139.     [contourLineColor selectCellAt:0:2];
  140.   }
  141.  
  142.   if(printColorMode){
  143.     [setDefaultPrintColor setState:1];
  144.     [printColor setState:1];
  145.   }
  146.   if(!printColorMode){
  147.     [setDefaultPrintColor setState:0];
  148.     [printColor setState:0];
  149.   }
  150.  
  151.   [setDefault2D3D display];
  152.   [setDefaultColor display];
  153.   [setDefaultPrintColor display];
  154.   [printColor display];
  155.   [setDefaultDiscipline display];
  156.   [chooseDiscipline display];
  157.   [choose2D3DData display];
  158.   [choose2D3DGrid display];
  159.  
  160.   if(colorOption)
  161.     {
  162.       [backgroundColor setColor:NX_COLORBLACK];
  163.       [foregroundColor setColor:NX_COLORWHITE];
  164.       [gridLineColor   setColor:NX_COLORLTGRAY];
  165.     }
  166.   if(!colorOption)
  167.     {
  168.       [foregroundColor setColor:NX_COLORBLACK];
  169.       [backgroundColor setColor:NX_COLORWHITE];
  170.       [gridLineColor   setColor:NX_COLORLTGRAY];
  171.     }
  172.  
  173.   gridIsReadIn = NO;
  174.   solutionIsReadIn = NO;
  175.   oldMin.x = 0.0;
  176.   oldMin.y = 0.0;
  177.   oldMax.x = 1.0;
  178.   oldMax.y = 1.0;
  179.   currentMin.x = 0.0;
  180.   currentMin.y = 0.0;
  181.   currentMax.x = 1.0;
  182.   currentMax.y = 1.0;
  183.  
  184.   [canvasWindow getFrame:&oldFrame];
  185.  
  186.   return self;
  187. }
  188.  
  189. - appDidInit:sender
  190. {
  191.   [canvasWindow     setMiniwindowIcon:"NeXTcontour.tiff"];
  192.   [controlsPanel    setMiniwindowIcon:"NeXTcontour.tiff"];
  193.   [preferencesPanel setMiniwindowIcon:"NeXTcontour.tiff"];
  194.   [subsetsPanel     setMiniwindowIcon:"NeXTcontour.tiff"];
  195.   [colorPanel       setMiniwindowIcon:"NeXTcontour.tiff"];
  196.   [helpPanel        setMiniwindowIcon:"NeXTcontour.tiff"];
  197.   [levelsPanel      setMiniwindowIcon:"NeXTcontour.tiff"];
  198.  
  199.   return self;
  200. }
  201.  
  202. - resetDefaults:sender
  203. {
  204.   int s1 = [setDefault2D3D state];
  205.   int s2 = [setDefaultDiscipline state];
  206.   int s3 = [setDefaultColor state];
  207.   int s4 = [setDefaultPrintColor state];
  208.   int s5 = [setDefaultDataForm state];
  209.   char s[4];
  210.  
  211.   s[0] = '5';
  212.   s[1] = '\0';
  213.   s[2] = '\0';
  214.   s[3] = '\0';
  215.  
  216.   switch(s1){
  217.   case 0:
  218.     Two_D = NO;
  219.     NXWriteDefault("NeXTcontour", "Two_D", "NO");
  220.     [choose2D3DData setState:0];
  221.     [choose2D3DGrid setState:0]; 
  222.    break;
  223.   case 1:
  224.     Two_D = YES;
  225.     NXWriteDefault("NeXTcontour", "Two_D", "YES");
  226.     [choose2D3DData setState:1];
  227.     [choose2D3DGrid setState:1];
  228.     break;
  229.   }
  230.  
  231.   switch(s2){
  232.   case 0:
  233.     AeroDynamic_Functions = YES;
  234.     NXWriteDefault("NeXTcontour", "AeroDynamics", "YES");
  235.     [chooseDiscipline setState:0];
  236.     if(Two_D){
  237.       [setDefaultNumberOfFunctions setIntValue:4 at:0];
  238.       number_Of_Functions_Read_In = 4;
  239.       [numberOfFunctions setIntValue:4 at:0];
  240.       NXWriteDefault("NeXTcontour", "number_Of_Functions_Read_In", "4");
  241.     }
  242.     if(!Two_D){
  243.       [setDefaultNumberOfFunctions setIntValue:5 at:0];
  244.       number_Of_Functions_Read_In = 5;
  245.       [numberOfFunctions setIntValue:5 at:0];
  246.       NXWriteDefault("NeXTcontour", "number_Of_Functions_Read_In", "5");
  247.     }
  248.     break;
  249.   case 1:
  250.     AeroDynamic_Functions = NO;
  251.     [chooseDiscipline setState:1];
  252.     NXWriteDefault("NeXTcontour", "AeroDynamics", "NO");
  253.     number_Of_Functions_Read_In = [setDefaultNumberOfFunctions intValueAt:0];
  254.     [numberOfFunctions setIntValue:number_Of_Functions_Read_In at:0];
  255.     sprintf(s,"%d",number_Of_Functions_Read_In);
  256.     NXWriteDefault("NeXTcontour", "number_Of_Functions_Read_In", s);
  257.     break;
  258.   }
  259.   
  260.   switch(s3){
  261.   case 0:
  262.     colorOption = YES;
  263.     NXWriteDefault("NeXTcontour", "colorOption", "YES");
  264.     [contourLineColor selectCellAt:0:3];
  265.     break;
  266.   case 1:
  267.     colorOption = NO;
  268.     NXWriteDefault("NeXTcontour", "colorOption", "NO");
  269.     [contourLineColor selectCellAt:0:2];
  270.     break;
  271.   }
  272.  
  273.   switch(s4){
  274.   case 0:
  275.     printColorMode = NO;
  276.     NXWriteDefault("NeXTcontour", "printColorMode", "NO");
  277.     [printColor setState:0];
  278.     break;
  279.   case 1:
  280.     printColorMode = YES;
  281.     NXWriteDefault("NeXTcontour", "printColorMode", "YES");
  282.     [printColor setState:1];
  283.     break;
  284.   }
  285.  
  286.   switch(s5){
  287.   case 0:
  288.     Binary_Data_Type = YES;
  289.     NXWriteDefault("NeXTcontour", "Binary_Data", "YES");
  290.     [chooseDataType setState:0];
  291.     break;
  292.   case 1:
  293.     Binary_Data_Type = NO;
  294.     NXWriteDefault("NeXTcontour", "Binary_Data", "NO");
  295.     [chooseDataType setState:1];
  296.     break;
  297.   }
  298.   
  299.   [printColor display];
  300.   [choose2D3DData display];
  301.   [choose2D3DGrid display];
  302.   [chooseDataType display];
  303.   [chooseDiscipline display];
  304.   [contourLineColor display];
  305.  
  306.   return self;
  307. }
  308.  
  309. - validRequestorForSendType:(NXAtom)sendType andReturnType:(NXAtom)returnType
  310. {
  311.   NXAtom a;
  312.   a = NXUniqueString(NXAsciiPboardType);
  313.   return (a==sendType)? self :nil;
  314. }
  315.  
  316. - writeSelectionToPasteboard:pboard types:(NXAtom *)types
  317. {
  318.   int i;
  319.   NXStream *my_stream;
  320.   int length, max_length;
  321.   char *data;
  322.  
  323.   my_stream = NXOpenMemory(NULL,0,NX_WRITEONLY);
  324.   for (i = 0; i < xyData.jmax; i++){
  325.     NXPrintf(my_stream,"%g %g \n", xyData.x[i], xyData.f[i]);
  326.   }
  327.  
  328.   NXGetMemoryBuffer(my_stream, &data, &length, &max_length);
  329.  
  330.   [pboard declareTypes:&NXAsciiPboardType num:1 owner:self];
  331.   [pboard writeType:NXAsciiPboardType data:data length:length];
  332.  
  333.   NXCloseMemory(my_stream, NX_TRUNCATEBUFFER);
  334.   return self;
  335. }
  336.  
  337. - (const char *)provideMainTitle   { return [mainTitle stringValueAt:0]; }
  338. - (const char *)provideFunctionTitle{ return [functionTitle stringValueAt:0];}
  339.  
  340. - (float)provideGridLineThickness { return [gridLineThickness floatValue]; }
  341. - (float)provideContourLineThickness{return [contourLineThickness floatValue];}
  342. - (NXCoord *)provideContourLevels:sender {  return contourLevels; }
  343.  
  344. - (NXColor) provideGridLineColor
  345. { 
  346.   if ((NXDrawingStatus == NX_PRINTING  && [printColor state] == 0) 
  347.       || ([printPreviewMode state] != 0 && [printColor state] == 0)){
  348.     if([gridLineColorMatrix selectedCol] == 0)return NX_COLORLTGRAY;
  349.     if([gridLineColorMatrix selectedCol] == 1)return NX_COLORDKGRAY;
  350.     if([gridLineColorMatrix selectedCol] == 2)return NX_COLORBLACK;
  351.   }
  352.   else{
  353.     if(colorOption){
  354.       return [gridLineColor color];
  355.     }
  356.     else {
  357.       if([gridLineColorMatrix selectedCol] == 0)return NX_COLORLTGRAY;
  358.       if([gridLineColorMatrix selectedCol] == 1)return NX_COLORDKGRAY;
  359.       if([gridLineColorMatrix selectedCol] == 2)return NX_COLORBLACK;
  360.     }
  361.   }
  362.   return NX_COLORBLACK;        // Never reached, put in to eliminate Compiler Warning
  363. }
  364.  
  365. - (NXColor) provideBackGroundColor
  366. {
  367.   if ((NXDrawingStatus == NX_PRINTING  && [printColor state] == 0)
  368.       || ([printPreviewMode state] != 0 && [printColor state] == 0)){
  369.     return NX_COLORWHITE;
  370.   }
  371.   else{
  372.     return [backgroundColor color];
  373.   }
  374. }
  375.  
  376. - (NXColor) provideForeGroundColor
  377. {
  378.   if (((NXDrawingStatus == NX_PRINTING  && [printColor state] == 0) 
  379.       || ([printPreviewMode state] != 0 && [printColor state] == 0))){
  380.     return NX_COLORBLACK;
  381.   }
  382.   else{
  383.     return [foregroundColor color];
  384.   }
  385. }
  386.  
  387. - (int) provideContourLineColor     
  388. {
  389.   int i = 2;
  390.   if ((NXDrawingStatus == NX_PRINTING  && [printColor state] == 0) 
  391.       || ([printPreviewMode state] != 0 && [printColor state] == 0)){
  392.     return i;
  393.   }
  394.   else{
  395.     if(!colorOption && [contourLineColor selectedCol]==3){
  396.       NXBeep();    beepError = 25;    /* audible alert */
  397.       [contourLineColor selectCellAt:0:2];
  398.     }
  399.     return [contourLineColor selectedCol]; 
  400.   }
  401. }
  402.  
  403. - (int) provideContourNumber:sender { return contourNumber;}
  404. - (int) provideViewingChoice:sender 
  405.                    {return [viewingTransformations selectedRow] + 4*
  406.               [viewingTransformations selectedCol]; }
  407. - (int) provideViewPoint:sender 
  408.                    {return [viewPoint state]; }
  409. - (int) provideFunctionChoice:sender
  410.                    { return [functionMatrix selectedRow];}
  411.  
  412. - (function_part)provideFunction:sender { return functionH; }
  413. - (grid_part)    provideGrid:sender     { return gridH; }
  414.  
  415.  
  416. - (NXCoord)provideFsmach { return solnhunk.fsmach; }
  417. - (NXCoord)provideAlpha  { return solnhunk.alpha; }
  418. - (NXCoord)provideRe     { return solnhunk.re; }
  419. - (NXCoord)provideTime   { return solnhunk.time; }
  420.  
  421. - (NXCoord)provideContourmin  {return [contourLimits floatValueAt:0];}
  422. - (NXCoord)provideContourmax  {return [contourLimits floatValueAt:1];}
  423. - (NXCoord)provideContourinc  {return [contourLimits floatValueAt:2];}
  424. - (NXCoord)provideFmin  {return [fMin floatValueAt:0];}
  425. - (NXCoord)provideFmax  {return [fMax floatValueAt:0];}
  426. - (NXCoord)provideXmin  {return [xyLimits floatValueAt:0];}
  427. - (NXCoord)provideXmax  {return [xyLimits floatValueAt:1];}
  428. - (NXCoord)provideYmin  {return [xyLimits floatValueAt:2];}
  429. - (NXCoord)provideYmax  {return [xyLimits floatValueAt:3];}
  430.  
  431. - (BOOL) doAnimateF
  432. {  if ( [animate3DFOnOff state] ) return YES;  else return NO; }
  433. - (BOOL) doAnimateG
  434. {  if ( [animate3DGOnOff state] ) return YES;  else return NO; }
  435.  
  436. - (BOOL) doSetAspectRatio
  437. {  if ( [setAspectRatio state] ) return NO;  else return YES; }
  438.  
  439. - (BOOL) do2D3D 
  440. {  if ( [choose2D3DData state] ) return YES;  else return NO; }
  441. - (BOOL) do2D3D_grid 
  442. {  if ( [choose2D3DGrid state] ) return YES;  else return NO; }
  443.  
  444. - (BOOL) doAeroDynamics 
  445. {  if ( [chooseDiscipline state] ) return NO;  else return YES; }
  446.  
  447.  
  448. - (BOOL) shouldChangeTitleFont
  449. {  if ( [changeTitleFont state] ) return YES;   else return NO; }
  450.  
  451. - (BOOL) shouldChangeLabelFont
  452. {  if ( [changeLabelFont state] ) return YES;   else return NO; }
  453.  
  454. - (BOOL) shouldShowXYLabels
  455. {  if ( [xyLabelsOn state] ) return YES;   else return NO; }
  456.  
  457. - (BOOL) shouldShowUnitsLabel
  458. {  if ( [unitsLabelOn state] ) return YES;   else return NO; }
  459.  
  460. - (BOOL) shouldShowContourValues
  461. {  if ( [contourValuesOn state] ) return YES;   else return NO; }
  462.  
  463. - (BOOL) doZoom
  464. {  if ( [zoomOnOff state] ) return YES;  else return NO; }
  465.  
  466. - (BOOL) doDrawFunction
  467. {  if ( [drawFunction state] ) return YES;   else return NO; }
  468.  
  469. - (BOOL) doDrawGrid
  470. {  if ( [drawGrid state] ) return YES;   else return NO; }
  471.  
  472. - (BOOL) doClearPlot
  473. {  if ( [clearPlot state] ) return NO;   else return YES; }
  474.  
  475. - (BOOL) doSolidLines
  476. {  if ( [solidContourLines state] ) return NO;   else return YES; }
  477.  
  478.  
  479. - resetCmin:(NXCoord)aNum { [contourLimits setFloatValue:aNum at:0]; 
  480.                 return self; }
  481. - resetCmax:(NXCoord)aNum { [contourLimits setFloatValue:aNum at:1]; 
  482.                 return self; }
  483. - resetCinc:(NXCoord)aNum { [contourLimits setFloatValue:aNum at:2]; 
  484.                 return self; }
  485. - resetFmin:(NXCoord)aNum { [fMin setFloatValue:aNum at:0]; return self; }
  486. - resetFmax:(NXCoord)aNum { [fMax setFloatValue:aNum at:0]; return self; }
  487. - resetXmin:(NXCoord)aNum { [xyLimits setFloatValue:aNum at:0]; return self; }
  488. - resetXmax:(NXCoord)aNum { [xyLimits setFloatValue:aNum at:1]; return self; }
  489. - resetYmin:(NXCoord)aNum { [xyLimits setFloatValue:aNum at:2]; return self; }
  490. - resetYmax:(NXCoord)aNum { [xyLimits setFloatValue:aNum at:3]; return self; }
  491.  
  492. -resetMinMax:sender
  493. {
  494.   if([self doDrawGrid] && ![self doDrawFunction]){
  495.     if(gridhunk.jmax != 0) [self loadGrid:self];
  496.     [self findGridMinAndMax];
  497.     [self resetGridMinMax:self];
  498.   }
  499.   if([self doDrawFunction]){
  500.     [self loadFunctionGrid:self];
  501.     [self findFunctionGridMinAndMax];
  502.     [self resetFunctionGridMinMax:self];
  503.   }
  504.   return self;
  505. }
  506.  
  507.  
  508. - resetGridMinMax:sender
  509. {
  510.   [self resetXmin:gridH.gridmin.x];
  511.   [self resetYmin:gridH.gridmin.y];
  512.   [self resetXmax:gridH.gridmax.x];
  513.   [self resetYmax:gridH.gridmax.y];
  514.   currentMin.x = gridH.gridmin.x;
  515.   currentMin.y = gridH.gridmin.y;
  516.   currentMax.x = gridH.gridmax.x;
  517.   currentMax.y = gridH.gridmax.y;
  518.   
  519.   return self;
  520. }
  521.  
  522. - resetFunctionGridMinMax:sender
  523. {
  524.   [self resetXmin:functionH.gridmin.x];
  525.   [self resetYmin:functionH.gridmin.y];
  526.   [self resetXmax:functionH.gridmax.x];
  527.   [self resetYmax:functionH.gridmax.y];
  528.   currentMin.x = functionH.gridmin.x;
  529.   currentMin.y = functionH.gridmin.y;
  530.   currentMax.x = functionH.gridmax.x;
  531.   currentMax.y = functionH.gridmax.y;
  532.   return self;
  533. }
  534.  
  535. - resetFunctionMinMax:sender
  536. {
  537.   [self resetFmin:functionH.functionmin];
  538.   [self resetFmax:functionH.functionmax];
  539.   return self;
  540. }
  541.  
  542. - resetGridSubsets:sender
  543. {
  544.   int i = 1;
  545.  
  546.     [jGridMax setIntValue:gridhunk.jmax at:0];
  547.     [kGridMax setIntValue:gridhunk.kmax at:0];
  548.     [lGridMax setIntValue:gridhunk.lmax at:0];
  549.     [jGridMin setIntValue:i at:0];
  550.     [kGridMin setIntValue:i at:0];
  551.     [lGridMin setIntValue:i at:0];
  552.     [jGridInc setIntValue:i at:0];
  553.     [kGridInc setIntValue:i at:0];
  554.     [lGridInc setIntValue:i at:0];
  555.  
  556.     return self;
  557. }
  558.  
  559.  
  560. - resetFunctionSubsets:sender
  561. {
  562.   int i = 1;
  563.     [jFunctionMax setIntValue:solnhunk.jmax at:0];
  564.     [kFunctionMax setIntValue:solnhunk.kmax at:0];
  565.     [lFunctionMax setIntValue:solnhunk.lmax at:0];
  566.     [jFunctionMin setIntValue:i at:0];
  567.     [kFunctionMin setIntValue:i at:0];
  568.     [lFunctionMin setIntValue:i at:0];
  569.     [jFunctionInc setIntValue:i at:0];
  570.     [kFunctionInc setIntValue:i at:0];
  571.     [lFunctionInc setIntValue:i at:0];
  572.     return self;
  573. }
  574.  
  575. - resetLineSubsets:sender
  576. {
  577.   int i = 1;
  578.   int lineChoice = [chooseLineData selectedRow];
  579.   BOOL b_2D = [self do2D3D];
  580.   
  581.   if(b_2D){
  582.     if(lineChoice == 2 ){
  583.       NXBeep();    beepError = 24;    /* audible alert */
  584.       lineChoice = 0;
  585.       [chooseLineData selectCellAt:lineChoice:0];
  586.     }
  587.   }
  588.  
  589.   switch(lineChoice){
  590.   case 0:
  591.     [jLineMax setIntValue:gridhunk.jmax at:0];
  592.     [kLineMax setIntValue:i at:0];
  593.     [lLineMax setIntValue:i at:0];
  594.     break;
  595.   case 1:
  596.     [kLineMax setIntValue:gridhunk.kmax at:0];
  597.     [jLineMax setIntValue:i at:0];
  598.     [lLineMax setIntValue:i at:0];
  599.     break;
  600.   case 2:
  601.     [lLineMax setIntValue:gridhunk.lmax at:0];
  602.     [kLineMax setIntValue:i at:0];
  603.     [jLineMax setIntValue:i at:0];
  604.     break;
  605.   }
  606.  
  607.   [jLineMin setIntValue:i at:0];
  608.   [kLineMin setIntValue:i at:0];
  609.   [lLineMin setIntValue:i at:0];
  610.   [jLineInc setIntValue:i at:0];
  611.   [kLineInc setIntValue:i at:0];
  612.   [lLineInc setIntValue:i at:0];
  613.   
  614.   return self;
  615. }
  616.  
  617. - resetAll:sender
  618. {
  619.   [self resetGridSubsets:self];
  620.   [self resetFunctionSubsets:self];
  621.   [self resetFunctionMinMax:self];
  622.   stateChangeGrid = YES;
  623.   stateChangeFunction = YES;
  624.   return self;
  625. }
  626.  
  627. - resetProjectionData:sender{  
  628.   stateChangeGrid = YES;  
  629.   stateChangeFunction = YES;  
  630.   return self;
  631. }
  632.  
  633. - resetGridLineColorWell:sender{  
  634.   if([gridLineColorMatrix selectedCol] == 0)
  635.     [gridLineColor   setColor:NX_COLORLTGRAY];
  636.   if([gridLineColorMatrix selectedCol] == 1)
  637.     [gridLineColor   setColor:NX_COLORDKGRAY];
  638.   if([gridLineColorMatrix selectedCol] == 2)
  639.     [gridLineColor   setColor:NX_COLORBLACK];
  640.   [gridLineColor display];
  641.   return self;
  642. }
  643.  
  644. - resetGridData:sender{  
  645.   [self resetGridSubsets:self];
  646.   stateChangeGrid = YES;  
  647.   return self;
  648. }
  649.  
  650. - resetLineData:sender{  
  651.   [self resetLineSubsets:self];
  652.   return self;
  653. }
  654.  
  655. - resetFunctionData:sender{  
  656.   [self resetFunctionSubsets:self];
  657.   stateChangeFunction = YES;  
  658.   return self;
  659. }
  660.  
  661. - eQuateSubsets:sender{
  662.   BOOL b_2D_grid = [self do2D3D_grid];
  663.   [jGridMin setIntValue:[jFunctionMin intValueAt:0] at:0];
  664.   [jGridMax setIntValue:[jFunctionMax intValueAt:0] at:0];
  665.   [jGridInc setIntValue:[jFunctionInc intValueAt:0] at:0];
  666.   [kGridMin setIntValue:[kFunctionMin intValueAt:0] at:0];
  667.   [kGridMax setIntValue:[kFunctionMax intValueAt:0] at:0];
  668.   [kGridInc setIntValue:[kFunctionInc intValueAt:0] at:0];
  669.   if(!b_2D_grid){
  670.     [lGridMin setIntValue:[lFunctionMin intValueAt:0] at:0];
  671.     [lGridMax setIntValue:[lFunctionMax intValueAt:0] at:0];
  672.     [lGridInc setIntValue:[lFunctionInc intValueAt:0] at:0];
  673.   }
  674.   if(b_2D_grid){
  675.     [lGridMin setIntValue:1 at:0];
  676.     [lGridMax setIntValue:1 at:0];
  677.     [lGridInc setIntValue:1 at:0];
  678.   }
  679.   [chooseGridPlane selectCellAt:[chooseFunctionPlane selectedRow]:0];
  680.   return self;
  681. }
  682.  
  683. - drawPlotButton:(int)state
  684. {
  685.   if (state==0) {
  686.     [plotButton highlight:NO];    /* will display normal title */
  687.   }
  688.   if (state==1) {
  689.     [plotButton highlight:YES];    /* will display alternate title */
  690.   }
  691.   return self;
  692. }
  693.  
  694.  
  695. - makeContourLevels:sender
  696. {
  697.   float fmin,fmax,finc;
  698.   int   ncont = 0,n;
  699.  
  700.   if( ![autoContours state] ){
  701.     
  702.     fmin  = [fMin floatValueAt:0];
  703.     fmax  = [fMax floatValueAt:0];
  704.     ncont = [numberContours intValueAt:0];
  705.     
  706.     if(ncont == 0){
  707.       ncont = 1;
  708.       [numberContours setIntValue:ncont at:0];
  709.     }
  710.  
  711.     finc = (fmax-fmin)/20.;
  712.     if(ncont != 1)finc = (fmax - fmin)/(ncont-1);
  713.     if(ncont == 1)finc = 0.0;
  714.  
  715.     [self resetCmin:fmin];    /* send contour level info to panel */
  716.     [self resetCmax:fmax];
  717.     [self resetCinc:finc];
  718.  
  719.     contourNumber = ncont;
  720.     free(contourLevels);
  721.     contourLevels = (NXCoord *)malloc(ncont*sizeof(float));
  722.  
  723.     for (n=0; n < ncont; n++){
  724.       contourLevels[n] = fmin + n*finc;
  725.     }
  726.   }
  727.   
  728.   else{
  729.  
  730.     fmin = [contourLimits floatValueAt:0];
  731.     fmax = [contourLimits floatValueAt:1];
  732.     finc = [contourLimits floatValueAt:2];
  733.  
  734.     if(finc == 0.0 && (fmax != fmin) ){
  735.       ncont = [numberContours intValueAt:0];
  736.       finc = (fmax-fmin)/ncont;
  737.       [self resetCinc:finc];
  738.     }
  739.  
  740.     if(finc != 0)ncont = (int)(ABS(fmax - fmin)/ABS(finc));
  741.     if(fmin + ncont*finc != fmax)ncont = ncont + 1;
  742.     if(fmin == fmax)ncont = 1;
  743.  
  744.     contourNumber = ncont;
  745.     free(contourLevels);
  746.     contourLevels = (NXCoord *)malloc(ncont*sizeof(float));
  747.  
  748.     for (n=0; n < ncont; n++){
  749.       contourLevels[n] = fmin + n*finc;
  750.     }
  751.     if(contourLevels[ncont-1] > fmax)contourLevels[ncont-1] = fmax;
  752.   }
  753.   
  754.   return self;
  755. }
  756.  
  757.  
  758. - drawPlot:sender
  759. {
  760.   /* get new subsets and function for plotting */
  761.  
  762.   BOOL animateF = [self doAnimateF];
  763.   BOOL animateG = [self doAnimateG];
  764.   BOOL b_2D = [self do2D3D];
  765.   int planeChoice = [chooseFunctionPlane selectedRow];
  766.   int i, i_0 = 0, i_m = 1, i_i = 1;
  767.   char c_xmin[20],c_xmax[20],c_ymin[20],c_ymax[20];
  768.   float xmin,xmax,ymin,ymax;
  769.  
  770.   /* error check */
  771.   if(animateF && ![self doDrawFunction])
  772.     {NXBeep(); beepError = 1; return self; }
  773.   if(animateG && ![self doDrawGrid])
  774.     {NXBeep(); beepError = 1; return self; }
  775.  
  776.   if([self doDrawGrid] && gridH.jmax == 0)
  777.     { NXBeep(); beepError = 2; return self; }
  778.  
  779.   if([self doDrawFunction] && functionH.jmax == 0)
  780.     {NXBeep(); beepError = 3; return self; }
  781.  
  782. /*  Need to convert the floating point vlaues of currentMin/Max to strings
  783.     and back to floats because: when TextFields are read the floating point 
  784.     values in the textfield is converted from a sting to a float.  If this is 
  785.     not done then the absolute comparison of the floating points values, (e.g.
  786.     currentMin.x != [xyLimits floatValueAt:0] ) will fail because of conversion
  787.     errors, causing all types of problems.  thp 1/10/92 
  788. */
  789.  
  790.   sprintf(c_xmin,"%g",currentMin.x);
  791.   sprintf(c_xmax,"%g",currentMax.x);
  792.   sprintf(c_ymin,"%g",currentMin.y);
  793.   sprintf(c_ymax,"%g",currentMax.y);
  794.   xmin = (float)atof(c_xmin);
  795.   ymin = (float)atof(c_ymin);
  796.   xmax = (float)atof(c_xmax);
  797.   ymax = (float)atof(c_ymax);
  798.  
  799.   if ( xmin != [xyLimits floatValueAt:0] 
  800.       || xmax != [xyLimits floatValueAt:1]
  801.       || ymin != [xyLimits floatValueAt:2]
  802.       || ymax != [xyLimits floatValueAt:3] ) {
  803.     oldMin.x = currentMin.x;
  804.     currentMin.x = [xyLimits floatValueAt:0];
  805.     oldMax.x = currentMax.x;
  806.     currentMax.x = [xyLimits floatValueAt:1];
  807.     oldMin.y = currentMin.y;
  808.     currentMin.y = [xyLimits floatValueAt:2];
  809.     oldMax.y = currentMax.y;
  810.     currentMax.y = [xyLimits floatValueAt:3];
  811.   }
  812.  
  813.   if(animateF && animateG)[self eQuateSubsets:self];
  814.  
  815.   if([printPreviewMode state] !=0){   /*  if preview mode reset clearplot */
  816.     [clearPlot setState:0];    [clearPlot display];
  817.   }
  818.  
  819.   /* function choices always take precedence over grid choices */
  820.   if(animateG && !animateF)planeChoice = [chooseGridPlane selectedRow];
  821.   if(animateF)planeChoice =              [chooseFunctionPlane selectedRow]; 
  822.  
  823.   switch(planeChoice){
  824.   case 0:
  825.     if(animateG && !animateF){
  826.       i_0 = [jGridMin intValueAt:0]-1;
  827.       i_i = [jGridInc intValueAt:0];
  828.       if(i_i <= 0){
  829.     NXBeep(); beepError = 26; 
  830.     i_i = 1;
  831.     [jGridInc setIntValue:i_i at:0];
  832.     return self; }
  833.       i_m = [jGridMax intValueAt:0]-1;
  834.     }
  835.     if(animateF){
  836.       i_0 = [jFunctionMin intValueAt:0]-1;
  837.       i_i = [jFunctionInc intValueAt:0];
  838.       if(i_i <= 0){
  839.     NXBeep(); beepError = 26; 
  840.     i_i = 1;
  841.     [jFunctionInc setIntValue:i_i at:0];
  842.     return self; }
  843.       i_m = [jFunctionMax intValueAt:0]-1;
  844.     }
  845.     break;
  846.   case 1:
  847.     if(animateG && !animateF){
  848.       i_0 = [kGridMin intValueAt:0]-1;
  849.       i_i = [kGridInc intValueAt:0];
  850.       if(i_i <= 0){
  851.     NXBeep(); beepError = 26; 
  852.     i_i = 1;
  853.     [kGridInc setIntValue:i_i at:0];
  854.     return self; }
  855.       i_m = [kGridMax intValueAt:0]-1;
  856.     }
  857.     if(animateF){
  858.       i_0 = [kFunctionMin intValueAt:0]-1;
  859.       i_i = [kFunctionInc intValueAt:0];
  860.       if(i_i <= 0){
  861.     NXBeep(); beepError = 26; 
  862.     i_i = 1;
  863.     [kFunctionInc setIntValue:i_i at:0];
  864.     return self; }
  865.       i_m = [kFunctionMax intValueAt:0]-1;
  866.     }
  867.     break;
  868.   case 2:
  869.     if(animateG && !animateF){
  870.       i_0 = [lGridMin intValueAt:0]-1;
  871.       i_i = [lGridInc intValueAt:0];
  872.       if(i_i <= 0){
  873.     NXBeep(); beepError = 26; 
  874.     i_i = 1;
  875.     [lGridInc setIntValue:i_i at:0];
  876.     return self; }
  877.       i_m = [lGridMax intValueAt:0]-1;
  878.     }
  879.     if(animateF){
  880.       i_0 = [lFunctionMin intValueAt:0]-1;
  881.       i_i = [lFunctionInc intValueAt:0];
  882.       if(i_i <= 0){
  883.     NXBeep(); beepError = 26; 
  884.     i_i = 1;
  885.     [lFunctionInc setIntValue:i_i at:0];
  886.     return self; }
  887.       i_m = [lFunctionMax intValueAt:0]-1;
  888.     }
  889.     break;
  890.   }
  891.  
  892.   if(b_2D || (!animateF && !animateG)){    i_i = 1;    i_m = i_0;   }
  893.  
  894.  
  895.   for (i = i_0; i <= i_m; i+= i_i){
  896.  
  897.     if(animateG){
  898.       switch(planeChoice){
  899.       case 0:
  900.     [jGridMin setIntValue:i+1 at:0];
  901.     break;
  902.       case 1:
  903.     [kGridMin setIntValue:i+1 at:0];
  904.     break;
  905.       case 2:
  906.     [lGridMin setIntValue:i+1 at:0];
  907.     break;
  908.       }
  909.     }
  910.     if([self doDrawGrid])[self loadGrid:self];
  911.  
  912.     if(animateF){
  913.       switch(planeChoice){
  914.       case 0:
  915.     [jFunctionMin setIntValue:i+1 at:0];
  916.     break;
  917.       case 1:
  918.     [kFunctionMin setIntValue:i+1 at:0];
  919.     break;
  920.       case 2:
  921.     [lFunctionMin setIntValue:i+1 at:0];
  922.     break;
  923.       }
  924.     }
  925.     if(solutionIsReadIn && [self doDrawFunction]){
  926.       [self loadFunctionGrid:self];
  927.       [self loadFunction:self];
  928.       [self makeContourLevels:self];
  929.     }
  930.       
  931.     if([self doDrawFunction] || [self doDrawGrid]){
  932.  
  933.       if([self checkMinMax] == 1){   /* check on min/max limits for errors */
  934.     NXBeep(); beepError = 4; return self; }
  935.  
  936.       if(NXDrawingStatus != NX_PRINTING){
  937.     [self drawPlotButton:1];    /* display "Plotting" */
  938.     [canvas display];
  939.     [self drawPlotButton:0];    /* display "Plot" */
  940.       }
  941.     }
  942.     else{ NXBeep(); beepError = 22; return self; }
  943.   }
  944.  
  945.   stateChangeGrid = NO;     /* reset stateChange so old min/max retained*/
  946.   stateChangeFunction = NO;     /* reset stateChange so old min/max retained*/
  947.  
  948.   return self;
  949. }
  950.  
  951.  
  952. // Go through a particular datahunk and find values for datamin.x,
  953. // datamax.x, datamin.y, datamax.y
  954.  
  955.   - findGridMinAndMax
  956. {
  957.   int j;
  958.  
  959.   gridH.gridmin.x = MAXFLOAT;    /* defined in /usr/include/math.h */
  960.   gridH.gridmax.x = -MAXFLOAT;
  961.   gridH.gridmin.y = MAXFLOAT;
  962.   gridH.gridmax.y = -MAXFLOAT;
  963.  
  964.   for (j = 0; j < gridH.jmax*gridH.kmax; j++)  {
  965.      gridH.gridmin.x = MIN(gridH.gridmin.x, gridH.x[j]);
  966.      gridH.gridmax.x = MAX(gridH.gridmax.x, gridH.x[j]);
  967.    }
  968.   for (j = 0; j < gridH.jmax*gridH.kmax; j++)  {
  969.      gridH.gridmin.y = MIN(gridH.gridmin.y, gridH.y[j]);
  970.      gridH.gridmax.y = MAX(gridH.gridmax.y, gridH.y[j]);
  971.    }
  972.   return self;
  973. }
  974.  
  975.   - findFunctionGridMinAndMax
  976. {
  977.   int j;
  978.  
  979.   functionH.gridmin.x = MAXFLOAT;    /* defined in /usr/include/math.h */
  980.   functionH.gridmax.x = -MAXFLOAT;
  981.   functionH.gridmin.y = MAXFLOAT;
  982.   functionH.gridmax.y = -MAXFLOAT;
  983.  
  984.   for (j = 0; j < functionH.jmax*functionH.kmax; j++)  {
  985.      functionH.gridmin.x = MIN(functionH.gridmin.x, functionH.x[j]);
  986.      functionH.gridmax.x = MAX(functionH.gridmax.x, functionH.x[j]);
  987.    }
  988.   for (j = 0; j < functionH.jmax*functionH.kmax; j++)  {
  989.      functionH.gridmin.y = MIN(functionH.gridmin.y, functionH.y[j]);
  990.      functionH.gridmax.y = MAX(functionH.gridmax.y, functionH.y[j]);
  991.    }
  992.   return self;
  993. }
  994.  
  995.   - findFunctionMinAndMax
  996. {
  997.   int j;
  998.  
  999.   functionH.functionmin = MAXFLOAT;    /* defined in /usr/include/math.h */
  1000.   functionH.functionmax = -MAXFLOAT;
  1001.  
  1002.  
  1003.   for (j = 0; j < functionH.jmax*functionH.kmax; j++)  {
  1004.      functionH.functionmin = MIN(functionH.functionmin, functionH.f[j]);
  1005.      functionH.functionmax = MAX(functionH.functionmax, functionH.f[j]);
  1006.    }
  1007.   return self;
  1008. }
  1009.  
  1010.  
  1011. // Use the OpenPanel object to get a filename
  1012. - openGrid:sender
  1013. {
  1014. //  char const  *fileTypes[2] = {"xy",0};  
  1015.   char const  *fileTypes[2] = {0,0};  
  1016.   char    fname[1024];
  1017.   
  1018.   [openPanel setTitle:"OPEN GRID FILE"];
  1019.  
  1020.   if ([openPanel runModalForTypes:fileTypes])  {
  1021.     strncpy(fname, [openPanel filename], 1024);
  1022.     [self openGridFile:fname];
  1023.   }
  1024.   return self;
  1025. }
  1026.  
  1027. // Use the OpenPanel object to get a filename
  1028. - openSolution:sender
  1029. {
  1030. //  char const  *fileTypes[2] = {"q",0};  
  1031.   char const  *fileTypes[2] = {0,0};  
  1032.   char    fname[1024];
  1033.  
  1034.   [openPanel setTitle:"OPEN DATA FILE"];
  1035.  
  1036.   if ([openPanel runModalForTypes:fileTypes])  {
  1037.     strncpy(fname, [openPanel filename], 1024);
  1038.     [self openSolnFile:fname];
  1039.   }
  1040.   return self;
  1041. }
  1042.  
  1043. - openGridFile:(char *)dataFile
  1044. {
  1045.     NXStream *dataStream;
  1046.  
  1047.     if ((dataStream = NXMapFile(dataFile, NX_READONLY)) == NULL)  {
  1048.       NXRunAlertPanel("Open", "Cannot open %s", "OK", NULL, NULL, dataFile);
  1049.       return self;
  1050.     }
  1051.  
  1052.     if ([self readGrid:dataStream :dataFile] == 0)  {
  1053.       NXRunAlertPanel("Read", "Couldn't read any data from %s", "OK",
  1054.               NULL, NULL, dataFile);
  1055.       NXCloseMemory(dataStream, NX_FREEBUFFER);
  1056.       return self;
  1057.     }
  1058.     NXCloseMemory(dataStream, NX_FREEBUFFER);
  1059.  
  1060.     [canvasWindow setTitleAsFilename:dataFile];
  1061.     return self;
  1062. }
  1063. - openSolnFile:(char *)dataFile
  1064. {
  1065.     NXStream *dataStream;
  1066.  
  1067.     if ((dataStream = NXMapFile(dataFile, NX_READONLY)) == NULL)  {
  1068.       NXRunAlertPanel("Open", "Cannot open %s", "OK", NULL, NULL, dataFile);
  1069.       return self;
  1070.     }
  1071.  
  1072.     if ([self readSoln:dataStream :dataFile] == 0)  {
  1073.       NXRunAlertPanel("Read", "Couldn't read any data from %s", "OK",
  1074.               NULL, NULL, dataFile);
  1075.       NXCloseMemory(dataStream, NX_FREEBUFFER);
  1076.       return self;
  1077.     }
  1078.     NXCloseMemory(dataStream, NX_FREEBUFFER);
  1079.  
  1080.     [canvasWindow setTitleAsFilename:dataFile];
  1081.     return self;
  1082. }
  1083.  
  1084.  
  1085.  
  1086. /* Allocate enough memory and read the data points */
  1087. - readGrid:(NXStream *)aDataStream :(char *)dataFile
  1088. {
  1089.   int j, numberofpoints, tmpint = 0;
  1090.   char c;
  1091.   BOOL b_2D = [self do2D3D_grid];
  1092.   int filesize,expected_filesize = 0, errorAlert = 0;
  1093.   struct stat filestat;
  1094.  
  1095.   /* set plot button title "Reading" */
  1096.   [plotButton setAltTitle:"Reading"];
  1097.   [plotButton highlight:YES];
  1098.   NXPing();            /* force plotButton redraw */
  1099.   
  1100.   if(![chooseDataType state]){
  1101.     NXRead(aDataStream, &gridhunk.jmax, sizeof(int));
  1102.     NXRead(aDataStream, &gridhunk.kmax, sizeof(int));
  1103.     if(!b_2D){ NXRead(aDataStream, &gridhunk.lmax, sizeof(int)); }
  1104.     else{gridhunk.lmax = 1;}
  1105.   }
  1106.   else{
  1107.     while((tmpint=NXScanf(aDataStream, "%d", &gridhunk.jmax)) == 0){
  1108.       c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1109.     }
  1110.     while((tmpint=NXScanf(aDataStream, "%d", &gridhunk.kmax)) == 0){
  1111.       c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1112.     }
  1113.     if(!b_2D){ 
  1114.       while((tmpint=NXScanf(aDataStream, "%d", &gridhunk.lmax)) == 0){
  1115.     c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1116.       }
  1117.     }
  1118.     else{gridhunk.lmax = 1;}
  1119.   }
  1120.  
  1121.   numberofpoints = gridhunk.jmax*gridhunk.kmax*gridhunk.lmax;
  1122.  
  1123.   if(![chooseDataType state]){
  1124.  
  1125.   /*  check file size */
  1126.     stat(dataFile,&filestat);
  1127.  
  1128.     filesize = filestat.st_size;
  1129.  
  1130.     if(b_2D){
  1131.       
  1132.       expected_filesize = 
  1133.     2*sizeof(int) + 2*sizeof(float)*numberofpoints;
  1134.  
  1135.       if(filesize != expected_filesize){
  1136.     errorAlert = NXRunAlertPanel("Read Grid File", 
  1137.                      "Not a Valid 2D Grid File! %s", 
  1138.                      "Try Again?","Continue?","Abort?", 
  1139.                      dataFile);
  1140.       
  1141.     if(errorAlert  != NX_ALERTALTERNATE){
  1142.       gridhunk.jmax = 0;
  1143.       gridhunk.kmax = 0;
  1144.       gridhunk.lmax = 0;
  1145.     }
  1146.     if(errorAlert  == NX_ALERTOTHER){
  1147.       /* reset plot button */
  1148.       [plotButton setAltTitle:"Plotting"];
  1149.       [plotButton highlight:NO];
  1150.       return self;
  1151.     }
  1152.     if(errorAlert  == NX_ALERTDEFAULT){
  1153.       /* reset plot button */
  1154.       [plotButton setAltTitle:"Plotting"];
  1155.       [plotButton highlight:NO];
  1156.       [self openGrid:self];
  1157.       return self;
  1158.     }
  1159.       }
  1160.     }
  1161.     if(!b_2D){
  1162.  
  1163.       expected_filesize = 
  1164.     3*sizeof(int) + 3*sizeof(float)*numberofpoints;
  1165.  
  1166.       if(filesize != expected_filesize){
  1167.     errorAlert = NXRunAlertPanel("Read Grid File", 
  1168.                      "Not a Valid 3D Grid File! %s ", 
  1169.                      "Try Again?","Continue?","Abort?",
  1170.                      dataFile);
  1171.     if(errorAlert  != NX_ALERTALTERNATE){
  1172.       gridhunk.jmax = 0;
  1173.       gridhunk.kmax = 0;
  1174.       gridhunk.lmax = 0;
  1175.     }
  1176.     if(errorAlert  == NX_ALERTOTHER){
  1177.       /* reset plot button */
  1178.       [plotButton setAltTitle:"Plotting"];
  1179.       [plotButton highlight:NO];
  1180.       return self;
  1181.     }
  1182.     if(errorAlert  == NX_ALERTDEFAULT){
  1183.       /* reset plot button */
  1184.       [plotButton setAltTitle:"Plotting"];
  1185.       [plotButton highlight:NO];
  1186.       [self openGrid:self];
  1187.       return self;
  1188.     }
  1189.       }
  1190.     }
  1191.   }
  1192.  
  1193.   free((void *)gridhunk.x);
  1194.   free((void *)gridhunk.y);
  1195.   gridhunk.x = (NXCoord *)malloc(numberofpoints*sizeof(float));
  1196.   gridhunk.y = (NXCoord *)malloc(numberofpoints*sizeof(float));
  1197.   if(!b_2D){ 
  1198.     free((void *)gridhunk.z);
  1199.     gridhunk.z = (NXCoord *)malloc(numberofpoints*sizeof(float)); 
  1200.   }
  1201.  
  1202.   if(![chooseDataType state]){
  1203.     NXRead(aDataStream, gridhunk.x, numberofpoints*sizeof(float));
  1204.     NXRead(aDataStream, gridhunk.y, numberofpoints*sizeof(float));
  1205.     if(!b_2D){NXRead(aDataStream, gridhunk.z, numberofpoints*sizeof(float)); }
  1206.   }
  1207.   else{
  1208.     for (j=0; j<numberofpoints; j++){
  1209.       while((tmpint=NXScanf(aDataStream, "%f", &gridhunk.x[j])) == 0){
  1210.     c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1211.       }
  1212.     }
  1213.     for (j=0; j<numberofpoints; j++){
  1214.       while((tmpint=NXScanf(aDataStream, "%f", &gridhunk.y[j])) == 0){
  1215.     c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1216.       }
  1217.     }
  1218.     if(!b_2D){
  1219.       for (j=0; j<numberofpoints; j++){
  1220.     while((tmpint=NXScanf(aDataStream, "%f", &gridhunk.z[j])) == 0){
  1221.       c = (char)NXGetc(aDataStream); /* throw away the next character */
  1222.     }
  1223.       }
  1224.     }
  1225.   }
  1226.   /* reset plot button */
  1227.   [plotButton setAltTitle:"Plotting"];
  1228.   [plotButton highlight:NO];
  1229.  
  1230.   /* initialize gridH from gridhunk */
  1231.   /* Initialize as 2D xy plane (jk plane) */
  1232.   gridH.jmax = gridhunk.jmax;
  1233.   gridH.kmax = gridhunk.kmax;
  1234.   free((void *)gridH.x);
  1235.   free((void *)gridH.y);
  1236.   gridH.x = (NXCoord *)malloc(gridH.jmax*gridH.kmax*sizeof(float));
  1237.   gridH.y = (NXCoord *)malloc(gridH.jmax*gridH.kmax*sizeof(float));
  1238.  
  1239.   for (j = 0; j < gridhunk.jmax*gridhunk.kmax; j++){
  1240.     gridH.x[j] = gridhunk.x[j];
  1241.     gridH.y[j] = gridhunk.y[j];
  1242.   }
  1243.       
  1244.   [self findGridMinAndMax];
  1245.  
  1246.  
  1247.   /*  On initial read function-grid min/max set to be same as grid min/max */
  1248.  
  1249.   gridhunk.gridmin.x = gridH.gridmin.x;
  1250.   gridhunk.gridmin.y = gridH.gridmin.y;
  1251.   gridhunk.gridmax.x = gridH.gridmax.x;
  1252.   gridhunk.gridmax.y = gridH.gridmax.y;
  1253.  
  1254.   /*  set min/max forms */
  1255.   [self resetGridSubsets:self];
  1256.   if(!gridIsReadIn){
  1257.     [self resetGridMinMax:self];
  1258.   }
  1259.   stateChangeGrid = NO;
  1260.   gridIsReadIn = YES;
  1261.   return self;
  1262. }
  1263.  
  1264. // Allocate enough memory and read the data points
  1265. - readSoln:(NXStream *)aDataStream :(char *)dataFile
  1266. {
  1267.   float gamma = 1.4;
  1268.   int j, numberofpoints,i,tmpint = 0;
  1269.   char c;
  1270.   BOOL b_2D = [self do2D3D];
  1271.   BOOL aero = [self doAeroDynamics];
  1272.   int filesize,expected_filesize = 0, errorAlert = 0;
  1273.   struct stat filestat;
  1274.   char title[14];
  1275.  
  1276.   /* set plot button title "Reading" */
  1277.   [plotButton setAltTitle:"Reading"];
  1278.   [plotButton highlight:YES];
  1279.   NXPing();            /* force plotButton redraw */
  1280.  
  1281.   number_Of_Functions_Read_In = [numberOfFunctions intValueAt:0];
  1282.  
  1283.   if(!aero){
  1284.  
  1285.     [functionMatrix setTitle:"Function 1" at:0:0];
  1286.     for(i=1; i< number_Of_Functions_Read_In; i++){
  1287.       sprintf(title,"Function %d",i+1);
  1288.       [functionMatrix setTitle:title at:i:0];
  1289.     }
  1290.     for(i=number_Of_Functions_Read_In; i<12; i++){
  1291.       [functionMatrix setTitle:"Inactive" at:i:0];
  1292.     }      
  1293.     [functionMatrix display];
  1294.   }
  1295.  
  1296.   if(aero){
  1297.     if(b_2D && number_Of_Functions_Read_In !=4){
  1298.       NXBeep();    beepError = 27;        /* audible alert */
  1299.       errorAlert = NXRunAlertPanel("Possible Read Data Error", 
  1300.                    "In 2D AeroDynamic Mode usually \n number of functions = 4 : you have %d", 
  1301.                    "Reset to 4","Continue?",NULL,
  1302.                    number_Of_Functions_Read_In);
  1303.       if(errorAlert  == NX_ALERTDEFAULT){
  1304.     number_Of_Functions_Read_In = 4;
  1305.     [numberOfFunctions setIntValue:4 at:0];
  1306.       }
  1307.  
  1308.     }
  1309.     if(!b_2D && number_Of_Functions_Read_In !=5){
  1310.       NXBeep();    beepError = 27;        /* audible alert */
  1311.       errorAlert = NXRunAlertPanel("Possible Read Data Error", 
  1312.                    "In 3D AeroDynamic Mode usually \n number of functions = 5 : you have %d", 
  1313.                    "Reset to 5","Continue?",NULL,
  1314.                    number_Of_Functions_Read_In);
  1315.       if(errorAlert  == NX_ALERTDEFAULT){
  1316.     number_Of_Functions_Read_In = 5;
  1317.     [numberOfFunctions setIntValue:5 at:0];
  1318.       }
  1319.  
  1320.     }
  1321.  
  1322.     if((b_2D && number_Of_Functions_Read_In !=4)||
  1323.        (!b_2D && number_Of_Functions_Read_In !=5)){
  1324.       [functionMatrix setTitle:"Function 1" at:0:0];
  1325.       for(i=1; i< number_Of_Functions_Read_In; i++){
  1326.     sprintf(title,"Function %d",i+1);
  1327.     [functionMatrix setTitle:title at:i:0];
  1328.       }
  1329.       for(i=number_Of_Functions_Read_In; i<12; i++){
  1330.     [functionMatrix setTitle:"Inactive" at:i:0];
  1331.       }      
  1332.     }
  1333.     else{
  1334.       [functionMatrix setTitle:"Q1: Density"    at:0:0];
  1335.       [functionMatrix setTitle:"Q2: U-Momentum" at:1:0];
  1336.       [functionMatrix setTitle:"Q3: V-Momentum" at:2:0];
  1337.       if(!b_2D)[functionMatrix setTitle:"Q4: W-Momentum" at:3:0];
  1338.       if(b_2D)[functionMatrix setTitle:"Inactive" at:3:0];
  1339.       if(!b_2D)[functionMatrix setTitle:"Q5: Energy"     at:4:0];
  1340.       if(b_2D)[functionMatrix setTitle:"Q4: Energy"     at:4:0];
  1341.       [functionMatrix setTitle:"Mach Number"    at:5:0];
  1342.       [functionMatrix setTitle:"Pressure"       at:6:0];
  1343.       [functionMatrix setTitle:"Cp"             at:7:0];
  1344.       [functionMatrix setTitle:"U-Velocity"     at:8:0];
  1345.       [functionMatrix setTitle:"V-Velocity"     at:9:0];
  1346.       if(!b_2D)[functionMatrix setTitle:"W-Velocity"     at:10:0];
  1347.       if(b_2D)[functionMatrix setTitle:"Inactive"     at:10:0];
  1348.     }
  1349.     [functionMatrix display];
  1350.  
  1351.   }
  1352.  
  1353.   if(![chooseDataType state]){
  1354.     NXRead(aDataStream, &solnhunk.jmax, sizeof(int));
  1355.     NXRead(aDataStream, &solnhunk.kmax, sizeof(int));
  1356.     if(!b_2D){ NXRead(aDataStream, &solnhunk.lmax, sizeof(int)); }
  1357.     else{solnhunk.lmax = 1;}
  1358.   }
  1359.   else{
  1360.     while((tmpint=NXScanf(aDataStream, "%d", &solnhunk.jmax)) == 0){
  1361.       c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1362.     }
  1363.     while((tmpint=NXScanf(aDataStream, "%d", &solnhunk.kmax)) == 0){
  1364.       c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1365.     }
  1366.     if(!b_2D){ 
  1367.       while((tmpint=NXScanf(aDataStream, "%d", &solnhunk.lmax)) == 0){
  1368.     c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1369.       }
  1370.     }
  1371.     else{solnhunk.lmax = 1;}
  1372.   }
  1373.  
  1374.   numberofpoints = solnhunk.jmax*solnhunk.kmax*solnhunk.lmax;
  1375.  
  1376.  
  1377.   if(![chooseDataType state]){
  1378.     /*  check file size */
  1379.     stat(dataFile,&filestat);
  1380.     
  1381.     filesize = filestat.st_size;
  1382.     
  1383.     if(b_2D){
  1384.       
  1385.       if(!aero)expected_filesize = 
  1386.     2*sizeof(int) + number_Of_Functions_Read_In*sizeof(float)*
  1387.       numberofpoints;
  1388.       
  1389.       if(aero)expected_filesize = 
  1390.     2*sizeof(int) + 4*sizeof(float) + 
  1391.       number_Of_Functions_Read_In*sizeof(float)*numberofpoints;
  1392.       
  1393.       if(filesize != expected_filesize){
  1394.     errorAlert = NXRunAlertPanel("Read Grid File Error", 
  1395.                      "Not a Valid 2D Data File! %s", 
  1396.                      "Try Again?","Continue","Abort?",
  1397.                      dataFile);
  1398.     if(errorAlert  != NX_ALERTALTERNATE){
  1399.       solnhunk.jmax = 0;
  1400.       solnhunk.kmax = 0;
  1401.       solnhunk.lmax = 0;
  1402.     }
  1403.     if(errorAlert  == NX_ALERTOTHER){
  1404.       /* reset plot button */
  1405.       [plotButton setAltTitle:"Plotting"];
  1406.       [plotButton highlight:NO];
  1407.       return self;
  1408.     }
  1409.     if(errorAlert  == NX_ALERTDEFAULT){
  1410.       /* reset plot button */
  1411.       [plotButton setAltTitle:"Plotting"];
  1412.       [plotButton highlight:NO];
  1413.       [self openSolution:self];
  1414.       return self;
  1415.     }
  1416.       }
  1417.     }
  1418.     
  1419.     if(!b_2D){
  1420.       if(!aero)expected_filesize = 
  1421.     3*sizeof(int) + number_Of_Functions_Read_In*sizeof(float)*
  1422.       numberofpoints;
  1423.       
  1424.       if(aero)expected_filesize = 
  1425.     3*sizeof(int) + 4*sizeof(float) + 
  1426.       number_Of_Functions_Read_In*sizeof(float)*numberofpoints;
  1427.       
  1428.       if(filesize != expected_filesize){
  1429.     errorAlert = NXRunAlertPanel("Read Data File Error", 
  1430.                      "Not a Valid 3D Data File! %s", 
  1431.                      "Try Again?","Continue?","Abort?",
  1432.                      dataFile);
  1433.     if(errorAlert  != NX_ALERTALTERNATE){
  1434.       solnhunk.jmax = 0;
  1435.       solnhunk.kmax = 0;
  1436.       solnhunk.lmax = 0;
  1437.     }
  1438.     if(errorAlert  == NX_ALERTOTHER){
  1439.       /* reset plot button */
  1440.       [plotButton setAltTitle:"Plotting"];
  1441.       [plotButton highlight:NO];
  1442.       return self;
  1443.     }
  1444.     if(errorAlert  == NX_ALERTDEFAULT){
  1445.       /* reset plot button */
  1446.       [plotButton setAltTitle:"Plotting"];
  1447.       [plotButton highlight:NO];
  1448.       [self openSolution:self];
  1449.       return self;
  1450.     }
  1451.       }
  1452.     }
  1453.   }
  1454.  
  1455.   /*  checkpoint on data grid sizes against grid file*/
  1456.   if( (gridhunk.jmax != solnhunk.jmax) || (gridhunk.kmax != solnhunk.kmax)
  1457.      || (gridhunk.lmax != solnhunk.lmax) ){
  1458.  
  1459.     if(gridhunk.jmax == 0 ){
  1460.       errorAlert = NXRunAlertPanel("Read Data FileError", 
  1461.                    "Need to Read In A Grid First", 
  1462.                    "Try Again?","Continue?", "Abort?");
  1463.     }
  1464.     else{
  1465.       if(b_2D)errorAlert = 
  1466.     NXRunAlertPanel("Read Data FileError", 
  1467.             "Inconsistent Dimensions, you had %d %d\n File %s", 
  1468.             "Try Again?","Continue?", "Abort?",
  1469.             solnhunk.jmax,solnhunk.kmax,dataFile);
  1470.       if(!b_2D)errorAlert = 
  1471.     NXRunAlertPanel("Read Data FileError", 
  1472.             "Inconsistent Dimensions, you had %d %d %d\n File %s", 
  1473.             "Try Again?","Continue?", "Abort?",
  1474.             solnhunk.jmax,solnhunk.kmax,solnhunk.lmax,dataFile);
  1475.     }
  1476.  
  1477.     if(errorAlert  != NX_ALERTALTERNATE){
  1478.       solnhunk.jmax = 0;
  1479.       solnhunk.kmax = 0;
  1480.       solnhunk.lmax = 0;
  1481.     }
  1482.     if(errorAlert  == NX_ALERTOTHER){
  1483.       /* reset plot button */
  1484.       [plotButton setAltTitle:"Plotting"];
  1485.       [plotButton highlight:NO];
  1486.       return self;
  1487.     }
  1488.     if(errorAlert  == NX_ALERTDEFAULT){
  1489.       /* reset plot button */
  1490.       [plotButton setAltTitle:"Plotting"];
  1491.       [plotButton highlight:NO];
  1492.       [self openSolution:self];
  1493.       return self;
  1494.     }
  1495.   }
  1496.  
  1497.   if(![chooseDataType state]){
  1498.     if(aero){
  1499.       NXRead(aDataStream, &solnhunk.fsmach, sizeof(float));
  1500.       NXRead(aDataStream, &solnhunk.alpha, sizeof(float));
  1501.       NXRead(aDataStream, &solnhunk.re, sizeof(float));
  1502.       NXRead(aDataStream, &solnhunk.time, sizeof(float));
  1503.     }
  1504.   }
  1505.   else{
  1506.     if(aero){
  1507.       while((tmpint=NXScanf(aDataStream, "%f", &solnhunk.fsmach)) == 0){
  1508.     c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1509.       }
  1510.       while((tmpint=NXScanf(aDataStream, "%f", &solnhunk.alpha)) == 0){
  1511.     c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1512.       }
  1513.       while((tmpint=NXScanf(aDataStream, "%f", &solnhunk.re)) == 0){
  1514.     c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1515.       }
  1516.       while((tmpint=NXScanf(aDataStream, "%f", &solnhunk.time)) == 0){
  1517.     c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1518.       }
  1519.     }
  1520.   }
  1521.   
  1522.   free((void *)solnhunk.functions);
  1523.   solnhunk.functions    = 
  1524.     (NXCoord *)malloc(number_Of_Functions_Read_In*
  1525.               numberofpoints*sizeof(float));
  1526.  
  1527.   if(aero){
  1528.     free((void *)solnhunk.pressure);
  1529.     free((void *)solnhunk.mach_number);
  1530.     solnhunk.pressure    = (NXCoord *)malloc(numberofpoints*sizeof(float));
  1531.     solnhunk.mach_number = (NXCoord *)malloc(numberofpoints*sizeof(float));
  1532.   }
  1533.  
  1534.   if(![chooseDataType state]){
  1535.     NXRead(aDataStream, solnhunk.functions,  
  1536.        number_Of_Functions_Read_In*numberofpoints*sizeof(float));
  1537.   }
  1538.   else{
  1539.     for (j=0; j<numberofpoints*number_Of_Functions_Read_In; j++){
  1540.       while((tmpint=NXScanf(aDataStream, "%f", &solnhunk.functions[j])) == 0){
  1541.     c = (char)NXGetc(aDataStream);    /* throw away the next character */
  1542.       }
  1543.     }
  1544.   }
  1545.  
  1546.   /*compute pressure and mach number here to speed up plotting */
  1547.   if(!b_2D && aero){
  1548.     for(i=0; i < numberofpoints; i++){
  1549.       
  1550.       solnhunk.mach_number[i] = 
  1551.      (solnhunk.functions[i+numberofpoints]*
  1552.       solnhunk.functions[i+numberofpoints] + 
  1553.       solnhunk.functions[i+2*numberofpoints]*
  1554.       solnhunk.functions[i+2*numberofpoints] + 
  1555.       solnhunk.functions[i+3*numberofpoints]*
  1556.       solnhunk.functions[i+3*numberofpoints]); 
  1557.  
  1558.  
  1559.       solnhunk.pressure[i] = (gamma-1.0)*
  1560.     (solnhunk.functions[i+4*numberofpoints] - 
  1561.      0.5* solnhunk.mach_number[i]/solnhunk.functions[i]);
  1562.  
  1563.       solnhunk.mach_number[i] = 
  1564.     sqrt(solnhunk.mach_number[i] / 
  1565.          (gamma * solnhunk.functions[i] * solnhunk.pressure[i]));
  1566.  
  1567.     }
  1568.   }
  1569.  
  1570.   if(b_2D && aero){
  1571.     for(i=0; i < numberofpoints; i++){
  1572.  
  1573.       solnhunk.mach_number[i] = 
  1574.      (solnhunk.functions[i+numberofpoints]*
  1575.       solnhunk.functions[i+numberofpoints] + 
  1576.       solnhunk.functions[i+2*numberofpoints]*
  1577.       solnhunk.functions[i+2*numberofpoints]);
  1578.  
  1579.  
  1580.       solnhunk.pressure[i] = (gamma-1.0)*
  1581.     (solnhunk.functions[i+3*numberofpoints] - 
  1582.      0.5* solnhunk.mach_number[i]/solnhunk.functions[i]);
  1583.  
  1584.       solnhunk.mach_number[i] = 
  1585.     sqrt(solnhunk.mach_number[i] / 
  1586.          (gamma * solnhunk.functions[i] * solnhunk.pressure[i]));
  1587.  
  1588.     }
  1589.   }
  1590.  
  1591.  
  1592.     /* reset plot button */
  1593.   [plotButton setAltTitle:"Plotting"];
  1594.   [plotButton highlight:NO];
  1595.  
  1596.   /* initialize functionH from gridhunk */
  1597.   /* Initialize as 2D xy plane (jk plane) */
  1598.   functionH.jmax = solnhunk.jmax;
  1599.   functionH.kmax = solnhunk.kmax;
  1600.  
  1601.   free((void *)functionH.x);  functionH.x = 
  1602.     (NXCoord *)malloc(functionH.jmax*functionH.kmax*sizeof(float));
  1603.   free((void *)functionH.y);  functionH.y = 
  1604.     (NXCoord *)malloc(functionH.jmax*functionH.kmax*sizeof(float));
  1605.   free((void *)functionH.f);  functionH.f = 
  1606.     (NXCoord *)malloc(functionH.jmax*functionH.kmax*sizeof(float));
  1607.  
  1608.   for (j=0; j < solnhunk.jmax*solnhunk.kmax; j++){
  1609.     functionH.x[j] = gridhunk.x[j];
  1610.     functionH.y[j] = gridhunk.y[j];
  1611.     functionH.f[j] = solnhunk.functions[j];
  1612.   }
  1613.  
  1614.   if(!solutionIsReadIn){
  1615.     [self resetFunctionSubsets:self];
  1616.     [self resetLineSubsets:self];
  1617.   }
  1618.  
  1619.   [self findFunctionGridMinAndMax];
  1620.   [self findFunctionMinAndMax];
  1621.   if(!solutionIsReadIn){
  1622.     [self resetFunctionGridMinMax:self];
  1623.     [self resetFunctionMinMax:self];
  1624.   }
  1625.   stateChangeFunction = NO;
  1626.   solutionIsReadIn = YES;
  1627.   return self;
  1628. }
  1629.  
  1630.  
  1631.  
  1632. - loadGrid:sender
  1633. {
  1634.   int  j, k, l, i, ii;
  1635.   int  jdim = gridhunk.jmax;
  1636.   int  kdim = gridhunk.kmax;
  1637.   int  jmax = gridhunk.jmax;
  1638.   int  kmax = gridhunk.kmax;
  1639.   int j_0,j_i,j_m,k_0,k_i,k_m,l_0,l_i,l_m;
  1640.   int planeChoice = [chooseGridPlane selectedRow];
  1641.   int viewChoice = 
  1642.     [viewingTransformations selectedRow] + 
  1643.       4*[viewingTransformations selectedCol];
  1644.   BOOL b_2D_grid = [self do2D3D_grid];
  1645.   BOOL b_2D = [self do2D3D];
  1646.  
  1647.   if(!b_2D && b_2D_grid)[self eQuateSubsets:self];
  1648.  
  1649.   /* failsafe for 2d/3d */
  1650.   if(b_2D_grid){
  1651.     if(viewChoice != 0 && viewChoice != 4 && viewChoice != 3){
  1652.       NXBeep(); beepError = 11;
  1653.       viewChoice = 0;
  1654.       [viewingTransformations selectCellAt:viewChoice:0];
  1655.     }
  1656.     if(planeChoice != 2){
  1657.       NXBeep(); beepError = 12;
  1658.       planeChoice = 2;
  1659.       [chooseGridPlane selectCellAt:planeChoice:0];
  1660.     }
  1661.   }
  1662.  
  1663.   
  1664. /* shift indices down 1  */
  1665.   j_0 = [jGridMin intValueAt:0] - 1;
  1666.   j_i = [jGridInc intValueAt:0];
  1667.   j_m = [jGridMax intValueAt:0] - 1;
  1668.  
  1669.   k_0 = [kGridMin intValueAt:0] - 1;
  1670.   k_i = [kGridInc intValueAt:0];
  1671.   k_m = [kGridMax intValueAt:0] - 1;
  1672.  
  1673.   l_0 = [lGridMin intValueAt:0] - 1;
  1674.   l_i = [lGridInc intValueAt:0];
  1675.   l_m = [lGridMax intValueAt:0] - 1;
  1676.   
  1677.  
  1678.   /* failsafe, j or k can never be <=0 || >= max*/
  1679.   if(j_i <= 0 || j_i > gridhunk.jmax){
  1680.     NXBeep();  beepError = 20;
  1681.     j_i = 1;
  1682.     [jGridInc setIntValue:j_i at:0];
  1683.   }
  1684.   if(j_0 < 0 || j_0 > gridhunk.jmax-1){
  1685.     NXBeep();  beepError = 20;
  1686.     j_0 = 0;
  1687.     [jGridMin setIntValue:j_0+1 at:0];
  1688.   }
  1689.   if(j_m < 0 || j_m > gridhunk.jmax-1){
  1690.     NXBeep();  beepError = 20;
  1691.     j_m = gridhunk.jmax-1;
  1692.     [jGridMax setIntValue:j_m+1 at:0];
  1693.   }
  1694.   if(j_m < j_0 && planeChoice != 0){
  1695.     NXBeep();  beepError = 20;
  1696.     j_0 = 0;
  1697.     [jGridMin setIntValue:j_0+1 at:0];
  1698.     j_m = gridhunk.jmax-1;
  1699.     [jGridMax setIntValue:j_m+1 at:0];
  1700.   }
  1701.   
  1702.   if(k_i <= 0 || k_i > gridhunk.kmax){
  1703.     NXBeep();  beepError = 20;
  1704.     k_i = 1;
  1705.     [kGridInc setIntValue:k_i at:0];
  1706.   }
  1707.   if(k_0 < 0 || k_0 > gridhunk.kmax-1){
  1708.     NXBeep();  beepError = 20;
  1709.     k_0 = 0;
  1710.     [kGridMin setIntValue:k_0+1 at:0];
  1711.   }
  1712.   if(k_m < 0 || k_m > gridhunk.kmax-1){
  1713.     NXBeep();  beepError = 20;
  1714.     k_m = gridhunk.kmax-1;
  1715.     [kGridMax setIntValue:k_m+1 at:0];
  1716.   }
  1717.   if(k_m < k_0 && planeChoice != 1){
  1718.     NXBeep();  beepError = 20;
  1719.     k_0 = 0;
  1720.     [kGridMin setIntValue:k_0+1 at:0];
  1721.     k_m = gridhunk.kmax-1;
  1722.     [kGridMax setIntValue:k_m+1 at:0];
  1723.   }
  1724.   
  1725.   if(l_i <= 0 || l_i > gridhunk.lmax){
  1726.     NXBeep();  beepError = 20;
  1727.     l_i = 1;
  1728.     [lGridInc setIntValue:l_i at:0];
  1729.   }
  1730.   if(l_0 < 0 || l_0 > gridhunk.lmax-1){
  1731.     NXBeep();  beepError = 20;
  1732.     l_0 = 0;
  1733.     [lGridMin setIntValue:l_0+1 at:0];
  1734.   }
  1735.   if(l_m < 0 || l_m > gridhunk.lmax-1){
  1736.     NXBeep();  beepError = 20;
  1737.     l_m = gridhunk.lmax-1;
  1738.     [lGridMax setIntValue:l_m+1 at:0];
  1739.   }
  1740.   if(l_m < l_0 && planeChoice != 2){
  1741.     NXBeep();  beepError = 20;
  1742.     l_0 = 0;
  1743.     [lGridMin setIntValue:l_0+1 at:0];
  1744.     l_m = gridhunk.lmax-1;
  1745.     [lGridMax setIntValue:l_m+1 at:0];
  1746.   }
  1747.  
  1748.  
  1749.   switch(planeChoice){
  1750.  
  1751.   case 0:
  1752.     jdim = (k_m - k_0)/k_i + 1;
  1753.     kdim = (l_m - l_0)/l_i + 1;
  1754.     j_m = j_0;
  1755.     [jGridMax setIntValue:j_m+1 at:0];
  1756.     j_i = 1;
  1757.     [jGridInc setIntValue:j_i at:0];
  1758.     break;
  1759.   case 1:
  1760.     jdim = (j_m - j_0)/j_i + 1;
  1761.     kdim = (l_m - l_0)/l_i + 1;
  1762.     k_m = k_0;
  1763.     [kGridMax setIntValue:k_m+1 at:0];
  1764.     k_i = 1;
  1765.     [kGridInc setIntValue:k_i at:0];
  1766.     break;
  1767.   case 2:
  1768.     jdim = (j_m - j_0)/j_i + 1;
  1769.     kdim = (k_m - k_0)/k_i + 1;
  1770.     l_m = l_0;
  1771.     [lGridMax setIntValue:l_m+1 at:0];
  1772.     l_i = 1;
  1773.     [lGridInc setIntValue:l_i at:0];
  1774.     break;
  1775.   }
  1776.  
  1777.   free((void *)gridH.x);
  1778.   free((void *)gridH.y);
  1779.   
  1780.   gridH.jmax = jdim;
  1781.   gridH.kmax = kdim;
  1782.   gridH.x = (NXCoord *)malloc(jdim*kdim*sizeof(float));
  1783.   gridH.y = (NXCoord *)malloc(jdim*kdim*sizeof(float));
  1784.   
  1785.   switch(viewChoice){
  1786.     
  1787.   case 0:
  1788.     ii = 0;
  1789.     for (l = l_0; l <= l_m; l= l + l_i){
  1790.       for (k = k_0; k <= k_m; k= k + k_i){
  1791.     for (j = j_0; j <= j_m; j = j + j_i){
  1792.       i = l*jmax*kmax + k*jmax + j;
  1793.       gridH.x[ii] = gridhunk.x[i];
  1794.       gridH.y[ii] = gridhunk.y[i];
  1795.       ii = ii+1;
  1796.     }
  1797.       }
  1798.     }
  1799.     break;
  1800.     
  1801.   case 1:
  1802.     
  1803.     ii = 0;
  1804.     for (l = l_0; l <= l_m; l= l + l_i){
  1805.       for (k = k_0; k <= k_m; k= k + k_i){
  1806.     for (j = j_0; j <= j_m; j = j + j_i){
  1807.       i = l*jmax*kmax + k*jmax + j;
  1808.       gridH.x[ii] = gridhunk.x[i];
  1809.       gridH.y[ii] = gridhunk.z[i];
  1810.       ii = ii+1;
  1811.     }
  1812.       }
  1813.     }
  1814.     break;
  1815.     
  1816.   case 2:
  1817.     
  1818.     ii = 0;
  1819.     for (l = l_0; l <= l_m; l= l + l_i){
  1820.       for (k = k_0; k <= k_m; k= k + k_i){
  1821.     for (j = j_0; j <= j_m; j = j + j_i){
  1822.       i = l*jmax*kmax + k*jmax + j;
  1823.       gridH.x[ii] = gridhunk.y[i];
  1824.       gridH.y[ii] = gridhunk.z[i];
  1825.       ii = ii+1;
  1826.     }
  1827.       }
  1828.     }
  1829.     break;
  1830.     
  1831.   case 3:
  1832.     
  1833.     ii = 0;
  1834.     for (l = l_0; l <= l_m; l= l + l_i){
  1835.       for (k = k_0; k <= k_m; k= k + k_i){
  1836.     for (j = j_0; j <= j_m; j = j + j_i){
  1837.       switch(planeChoice){
  1838.       case 2:
  1839.         gridH.x[ii] = (float)j+1;
  1840.         gridH.y[ii] = (float)k+1;
  1841.         break;
  1842.       case 0:
  1843.         gridH.x[ii] = (float)k+1;
  1844.         gridH.y[ii] = (float)l+1;
  1845.         break;
  1846.       case 1:
  1847.         gridH.x[ii] = (float)j+1;
  1848.         gridH.y[ii] = (float)l+1;
  1849.         break;
  1850.       }
  1851.       ii = ii+1;
  1852.     }
  1853.       }
  1854.     }
  1855.     break;
  1856.     
  1857.   case 4:
  1858.     ii = 0;
  1859.     for (l = l_0; l <= l_m; l= l + l_i){
  1860.       for (k = k_0; k <= k_m; k= k + k_i){
  1861.     for (j = j_0; j <= j_m; j = j + j_i){
  1862.       i = l*jmax*kmax + k*jmax + j;
  1863.       gridH.x[ii] = gridhunk.y[i];
  1864.       gridH.y[ii] = gridhunk.x[i];
  1865.       ii = ii+1;
  1866.     }
  1867.       }
  1868.     }
  1869.     break;
  1870.     
  1871.   case 5:
  1872.     
  1873.     ii = 0;
  1874.     for (l = l_0; l <= l_m; l= l + l_i){
  1875.       for (k = k_0; k <= k_m; k= k + k_i){
  1876.     for (j = j_0; j <= j_m; j = j + j_i){
  1877.       i = l*jmax*kmax + k*jmax + j;
  1878.       gridH.x[ii] = gridhunk.z[i];
  1879.       gridH.y[ii] = gridhunk.x[i];
  1880.       ii = ii+1;
  1881.     }
  1882.       }
  1883.     }
  1884.     break;
  1885.     
  1886.   case 6:
  1887.     
  1888.     ii = 0;
  1889.     for (l = l_0; l <= l_m; l= l + l_i){
  1890.       for (k = k_0; k <= k_m; k= k + k_i){
  1891.     for (j = j_0; j <= j_m; j = j + j_i){
  1892.       i = l*jmax*kmax + k*jmax + j;
  1893.       gridH.x[ii] = gridhunk.z[i];
  1894.       gridH.y[ii] = gridhunk.y[i];
  1895.       ii = ii+1;
  1896.     }
  1897.       }
  1898.     }
  1899.     break;
  1900.   }
  1901.   
  1902.   [self findGridMinAndMax];
  1903. ///////  if(stateChangeGrid && !stateChangeFunction)[self resetGridMinMax:self];
  1904.   
  1905.   return self;
  1906. }
  1907.  
  1908. - loadFunction:sender
  1909. {
  1910.   int  j, k, l, i, ii;
  1911.   int  jdim = solnhunk.jmax;
  1912.   int  kdim = solnhunk.kmax;
  1913.   int  jmax = solnhunk.jmax;
  1914.   int  kmax = solnhunk.kmax;
  1915.   int j_0,j_i,j_m,k_0,k_i,k_m,l_0,l_i,l_m;
  1916.   int planeChoice = [chooseFunctionPlane selectedRow];
  1917.   int viewChoice = 
  1918.     [viewingTransformations selectedRow] + 
  1919.       4*[viewingTransformations selectedCol];
  1920.   int functionChoice = [functionMatrix selectedRow];
  1921.   BOOL b_2D = [self do2D3D];
  1922.   BOOL aero = [self doAeroDynamics];
  1923.   float gamma = 1.4;
  1924.   int numberofpoints;
  1925.   
  1926.   numberofpoints = solnhunk.jmax*solnhunk.kmax*solnhunk.lmax;
  1927.  
  1928.   /* failsafes for 2d/3d multiple vrs single functions*/
  1929.  
  1930.   if(!aero && functionChoice+1 > number_Of_Functions_Read_In ){
  1931.     NXBeep();    beepError = 13;        /* audible alert */
  1932.     functionChoice = 0;
  1933.     [functionMatrix selectCellAt:functionChoice:0];
  1934.   }
  1935.  
  1936.   if(aero){
  1937.     if((number_Of_Functions_Read_In != 4 && b_2D) ||
  1938.        (number_Of_Functions_Read_In != 5 && !b_2D)){
  1939.       if(functionChoice+1 > number_Of_Functions_Read_In ){
  1940.     NXBeep();    beepError = 13;        /* audible alert */
  1941.     functionChoice = 0;
  1942.     [functionMatrix selectCellAt:functionChoice:0];
  1943.       }
  1944.     }
  1945.   }
  1946.  
  1947.   if(b_2D){
  1948.     if((functionChoice == 3 || functionChoice == 10 )
  1949.        && (aero && number_Of_Functions_Read_In == 4)){
  1950.       NXBeep();    beepError = 14;    /* audible alert */
  1951.       functionChoice = 0;
  1952.       [functionMatrix selectCellAt:functionChoice:0];
  1953.     }
  1954.     if(viewChoice != 0 && viewChoice != 4 && viewChoice != 3){
  1955.       NXBeep();  beepError = 15;
  1956.       viewChoice = 0;
  1957.       [viewingTransformations selectCellAt:viewChoice:0];
  1958.     }
  1959.     if(planeChoice != 2){
  1960.       NXBeep(); beepError = 16;
  1961.       planeChoice = 2;
  1962.       [chooseFunctionPlane selectCellAt:planeChoice:0];
  1963.     }
  1964.   }
  1965.  
  1966.  
  1967.   /* shift indices down 1  */
  1968.   j_0 = [jFunctionMin intValueAt:0] - 1;
  1969.   j_i = [jFunctionInc intValueAt:0];
  1970.   j_m = [jFunctionMax intValueAt:0] - 1;
  1971.  
  1972.   k_0 = [kFunctionMin intValueAt:0] - 1;
  1973.   k_i = [kFunctionInc intValueAt:0];
  1974.   k_m = [kFunctionMax intValueAt:0] - 1;
  1975.  
  1976.   l_0 = [lFunctionMin intValueAt:0] - 1;
  1977.   l_i = [lFunctionInc intValueAt:0];
  1978.   l_m = [lFunctionMax intValueAt:0] - 1;
  1979.   
  1980.  
  1981.   /* failsafe, j or k can never be <=0 || >= max*/
  1982.       if(j_i <= 0 || j_i > solnhunk.jmax){
  1983.     NXBeep();  beepError = 21;
  1984.     j_i = 1;
  1985.     [jFunctionInc setIntValue:j_i at:0];
  1986.       }
  1987.       if(j_0 < 0 || j_0 > solnhunk.jmax-1){
  1988.     NXBeep();  beepError = 21;
  1989.     j_0 = 0;
  1990.     [jFunctionMin setIntValue:j_0+1 at:0];
  1991.       }
  1992.       if(j_m < 0 || j_m > solnhunk.jmax-1){
  1993.     NXBeep();  beepError = 21;
  1994.     j_m = solnhunk.jmax-1;
  1995.     [jFunctionMax setIntValue:j_m+1 at:0];
  1996.       }
  1997.       if(j_m < j_0 && planeChoice != 0){
  1998.     NXBeep();  beepError = 21;
  1999.     j_0 = 0;
  2000.     [jFunctionMin setIntValue:j_0+1 at:0];
  2001.     j_m = solnhunk.jmax-1;
  2002.     [jFunctionMax setIntValue:j_m+1 at:0];
  2003.       }
  2004.  
  2005.       if(k_i <= 0 || k_i > solnhunk.kmax){
  2006.     NXBeep();  beepError = 21;
  2007.     k_i = 1;
  2008.     [kFunctionInc setIntValue:k_i at:0];
  2009.       }
  2010.       if(k_0 < 0 || k_0 > solnhunk.kmax-1){
  2011.     NXBeep();  beepError = 21;
  2012.     k_0 = 0;
  2013.     [kFunctionMin setIntValue:k_0+1 at:0];
  2014.       }
  2015.       if(k_m < 0 || k_m > solnhunk.kmax-1){
  2016.     NXBeep();  beepError = 21;
  2017.     k_m = solnhunk.kmax-1;
  2018.     [kFunctionMax setIntValue:k_m+1 at:0];
  2019.       }
  2020.       if(k_m < k_0 && planeChoice != 1){
  2021.     NXBeep();  beepError = 21;
  2022.     k_0 = 0;
  2023.     [kFunctionMin setIntValue:k_0+1 at:0];
  2024.     k_m = solnhunk.kmax-1;
  2025.     [kFunctionMax setIntValue:k_m+1 at:0];
  2026.       }
  2027.  
  2028.       if(l_i <= 0 || l_i > solnhunk.lmax){
  2029.     NXBeep();  beepError = 21;
  2030.     l_i = 1;
  2031.     [lFunctionInc setIntValue:l_i at:0];
  2032.       }
  2033.       if(l_0 < 0 || l_0 > solnhunk.lmax-1){
  2034.     NXBeep();  beepError = 21;
  2035.     l_0 = 0;
  2036.     [lFunctionMin setIntValue:l_0+1 at:0];
  2037.       }
  2038.       if(l_m < 0 || l_m > solnhunk.lmax-1){
  2039.     NXBeep();  beepError = 21;
  2040.     l_m = solnhunk.lmax-1;
  2041.     [lFunctionMax setIntValue:l_m+1 at:0];
  2042.       }
  2043.       if(l_m < l_0 && planeChoice != 2){
  2044.     NXBeep();  beepError = 21;
  2045.     l_0 = 0;
  2046.     [lFunctionMin setIntValue:l_0+1 at:0];
  2047.     l_m = solnhunk.lmax-1;
  2048.     [lFunctionMax setIntValue:l_m+1 at:0];
  2049.       }
  2050.   
  2051.   switch(planeChoice){
  2052.     
  2053.   case 0:
  2054.     jdim = (k_m - k_0)/k_i + 1;
  2055.     kdim = (l_m - l_0)/l_i + 1;
  2056.     j_m = j_0;
  2057.     [jFunctionMax setIntValue:j_m+1 at:0];
  2058.     j_i = 1;
  2059.     [jFunctionInc setIntValue:j_i at:0];
  2060.     break;
  2061.   case 1:
  2062.     jdim = (j_m - j_0)/j_i + 1;
  2063.     kdim = (l_m - l_0)/l_i + 1;
  2064.     k_m = k_0;
  2065.     [kFunctionMax setIntValue:k_m+1 at:0];
  2066.     k_i = 1;
  2067.     [kFunctionInc setIntValue:k_i at:0];
  2068.     break;
  2069.   case 2:
  2070.     jdim = (j_m - j_0)/j_i + 1;
  2071.     kdim = (k_m - k_0)/k_i + 1;
  2072.     l_m = l_0;
  2073.     [lFunctionMax setIntValue:l_m+1 at:0];
  2074.     l_i = 1;
  2075.     [lFunctionInc setIntValue:l_i at:0];
  2076.     break;
  2077.   }
  2078.  
  2079.   free((void *)functionH.f);
  2080.  
  2081.   functionH.jmax = jdim;
  2082.   functionH.kmax = kdim;
  2083.   functionH.f =  (NXCoord *)malloc(jdim*kdim*sizeof(float));
  2084.  
  2085.  
  2086.   /* load up subset function for plotting */
  2087.   
  2088.   if(aero){
  2089.     if((number_Of_Functions_Read_In == 4 && b_2D) ||
  2090.        (number_Of_Functions_Read_In == 5 && !b_2D)){
  2091.       ii = 0;
  2092.       for (l = l_0; l <= l_m; l= l + l_i){
  2093.     for (k = k_0; k <= k_m; k= k + k_i){
  2094.       for (j = j_0; j <= j_m; j = j + j_i){
  2095.         i = l*jmax*kmax + k*jmax + j;
  2096.         
  2097.         switch(functionChoice){
  2098.         case 0:                                  /* Q1: Density    */
  2099.           functionH.f[ii] = solnhunk.functions[i];  
  2100.           break;
  2101.         case 1:                                  /* Q2: U Momentum */
  2102.           functionH.f[ii] = solnhunk.functions[i+numberofpoints];
  2103.           break;
  2104.         case 2:                                  /* Q3: V Momentum */
  2105.           functionH.f[ii] = solnhunk.functions[i+2*numberofpoints];
  2106.           break;
  2107.         case 3:                                  /* Q4: W Momentum */
  2108.           functionH.f[ii] = solnhunk.functions[i+3*numberofpoints];
  2109.           break;
  2110.         case 4:                                  /* Q5: Energy     */
  2111.           if(!b_2D)functionH.f[ii] = 
  2112.         solnhunk.functions[i+4*numberofpoints];
  2113.           if(b_2D)functionH.f[ii] = solnhunk.functions[i+3*numberofpoints];
  2114.           break;
  2115.         case 5:                                  /* Mach Number    */
  2116.           functionH.f[ii] = solnhunk.mach_number[i];
  2117.           break;
  2118.         case 6:                                  /* Pressure       */
  2119.           functionH.f[ii] = solnhunk.pressure[i];
  2120.           break;
  2121.         case 7:
  2122.           functionH.f[ii] =                      /* Cp             */
  2123.         2.0/(gamma*solnhunk.fsmach*solnhunk.fsmach) * 
  2124.           (solnhunk.pressure[i]*gamma - 1.);
  2125.           break;
  2126.         case 8:                                  /* U Velocity     */
  2127.           functionH.f[ii] = 
  2128.         solnhunk.functions[i+numberofpoints]/solnhunk.functions[i];
  2129.           break;
  2130.         case 9:                                  /* V Velocity     */
  2131.           functionH.f[ii] = 
  2132.         solnhunk.functions[i+2*numberofpoints]/solnhunk.functions[i];
  2133.           break;
  2134.         case 10:                                 /* W Velocity     */
  2135.           functionH.f[ii] = 
  2136.         solnhunk.functions[i+3*numberofpoints]/solnhunk.functions[i];
  2137.           break;
  2138.         }
  2139.         ii = ii+1;
  2140.       }
  2141.     }
  2142.       }
  2143.     }
  2144.     else{
  2145.       ii = 0;
  2146.       for (l = l_0; l <= l_m; l= l + l_i){
  2147.     for (k = k_0; k <= k_m; k= k + k_i){
  2148.       for (j = j_0; j <= j_m; j = j + j_i){
  2149.         i = l*jmax*kmax + k*jmax + j;
  2150.         functionH.f[ii] = 
  2151.           solnhunk.functions[i + functionChoice*numberofpoints];
  2152.         ii = ii+1;
  2153.       }
  2154.     }
  2155.       }
  2156.     }
  2157.   }
  2158.   
  2159.   if(!aero){
  2160.     ii = 0;
  2161.     for (l = l_0; l <= l_m; l= l + l_i){
  2162.       for (k = k_0; k <= k_m; k= k + k_i){
  2163.     for (j = j_0; j <= j_m; j = j + j_i){
  2164.       i = l*jmax*kmax + k*jmax + j;
  2165.       functionH.f[ii] = 
  2166.         solnhunk.functions[i + functionChoice*numberofpoints];
  2167.       ii = ii+1;
  2168.     }
  2169.       }
  2170.     }
  2171.   }
  2172.   
  2173.   
  2174.   [self findFunctionMinAndMax];
  2175.   [self resetFunctionMinMax:self];  
  2176.  
  2177.   return self;
  2178. }
  2179.  
  2180. - loadFunctionGrid:sender
  2181. {
  2182.   int  j, k, l, i, ii;
  2183.   BOOL b_2D = [self do2D3D];
  2184.   BOOL b_2D_grid = [self do2D3D_grid];
  2185.   int jdim,kdim,jmax,kmax,planeChoice;
  2186.   int j_0,j_i,j_m,k_0,k_i,k_m,l_0,l_i,l_m;
  2187.   int viewChoice = 
  2188.     [viewingTransformations selectedRow] + 
  2189.       4*[viewingTransformations selectedCol];
  2190.  
  2191.   if(b_2D == b_2D_grid){
  2192.     jdim = solnhunk.jmax;
  2193.     kdim = solnhunk.kmax;
  2194.     jmax = solnhunk.jmax;
  2195.     kmax = solnhunk.kmax;
  2196.     planeChoice = [chooseFunctionPlane selectedRow];}
  2197.   else{
  2198.     jdim = gridhunk.jmax;
  2199.     kdim = gridhunk.kmax;
  2200.     jmax = gridhunk.jmax;
  2201.     kmax = gridhunk.kmax;
  2202.     planeChoice = [chooseGridPlane selectedRow];}
  2203.  
  2204.   /* failsafe for 2d/3d */
  2205.   if(b_2D_grid){
  2206.     if(viewChoice != 0 && viewChoice != 4 && viewChoice != 3){
  2207.       NXBeep(); beepError = 18;
  2208.       viewChoice = 0;
  2209.       [viewingTransformations selectCellAt:viewChoice:0];
  2210.     }
  2211.     if(planeChoice != 2){
  2212.       NXBeep();  beepError = 19;
  2213.       planeChoice = 2;
  2214.       if(b_2D == b_2D_grid)[chooseFunctionPlane selectCellAt:planeChoice:0];
  2215.       if(b_2D != b_2D_grid)[chooseGridPlane selectCellAt:planeChoice:0];
  2216.     }
  2217.   }
  2218.  
  2219.  
  2220.   /* shift indices down 1  */
  2221.   if(b_2D == b_2D_grid){
  2222.     j_0 = [jFunctionMin intValueAt:0] - 1;
  2223.     j_i = [jFunctionInc intValueAt:0];
  2224.     j_m = [jFunctionMax intValueAt:0] - 1;
  2225.  
  2226.     k_0 = [kFunctionMin intValueAt:0] - 1;
  2227.     k_i = [kFunctionInc intValueAt:0];
  2228.     k_m = [kFunctionMax intValueAt:0] - 1;
  2229.  
  2230.     l_0 = [lFunctionMin intValueAt:0] - 1;
  2231.     l_i = [lFunctionInc intValueAt:0];
  2232.     l_m = [lFunctionMax intValueAt:0] - 1;
  2233.  
  2234.   /* failsafe, j or k can never be <=0 || >= max*/
  2235.     if(j_i <= 0 || j_i > solnhunk.jmax){
  2236.       NXBeep();  beepError = 21;
  2237.       j_i = 1;
  2238.       [jFunctionInc setIntValue:j_i at:0];
  2239.     }
  2240.     if(j_0 < 0 || j_0 > solnhunk.jmax-1){
  2241.       NXBeep();  beepError = 21;
  2242.       j_0 = 0;
  2243.       [jFunctionMin setIntValue:j_0+1 at:0];
  2244.     }
  2245.     if(j_m < 0 || j_m > solnhunk.jmax-1){
  2246.       NXBeep();  beepError = 21;
  2247.       j_m = solnhunk.jmax-1;
  2248.       [jFunctionMax setIntValue:j_m+1 at:0];
  2249.     }
  2250.     if(j_m < j_0 && planeChoice != 0){
  2251.       NXBeep();  beepError = 21;
  2252.       j_0 = 0;
  2253.       [jFunctionMin setIntValue:j_0+1 at:0];
  2254.       j_m = solnhunk.jmax-1;
  2255.       [jFunctionMax setIntValue:j_m+1 at:0];
  2256.     }
  2257.     
  2258.     if(k_i <= 0 || k_i > solnhunk.kmax){
  2259.       NXBeep();  beepError = 21;
  2260.       k_i = 1;
  2261.       [kFunctionInc setIntValue:k_i at:0];
  2262.     }
  2263.     if(k_0 < 0 || k_0 > solnhunk.kmax-1){
  2264.       NXBeep();  beepError = 21;
  2265.       k_0 = 0;
  2266.       [kFunctionMin setIntValue:k_0+1 at:0];
  2267.     }
  2268.     if(k_m < 0 || k_m > solnhunk.kmax-1){
  2269.       NXBeep();  beepError = 21;
  2270.       k_m = solnhunk.kmax-1;
  2271.       [kFunctionMax setIntValue:k_m+1 at:0];
  2272.     }
  2273.     if(k_m < k_0 && planeChoice != 1){
  2274.       NXBeep();  beepError = 21;
  2275.       k_0 = 0;
  2276.       [kFunctionMin setIntValue:k_0+1 at:0];
  2277.       k_m = solnhunk.kmax-1;
  2278.       [kFunctionMax setIntValue:k_m+1 at:0];
  2279.     }
  2280.     
  2281.     if(l_i <= 0 || l_i > solnhunk.lmax){
  2282.       NXBeep();  beepError = 21;
  2283.       l_i = 1;
  2284.       [lFunctionInc setIntValue:l_i at:0];
  2285.     }
  2286.     if(l_0 < 0 || l_0 > solnhunk.lmax-1){
  2287.       NXBeep();  beepError = 21;
  2288.       l_0 = 0;
  2289.       [lFunctionMin setIntValue:l_0+1 at:0];
  2290.     }
  2291.     if(l_m < 0 || l_m > solnhunk.lmax-1){
  2292.       NXBeep();  beepError = 21;
  2293.       l_m = solnhunk.lmax-1;
  2294.       [lFunctionMax setIntValue:l_m+1 at:0];
  2295.     }
  2296.     if(l_m < l_0 && planeChoice != 2){
  2297.       NXBeep();  beepError = 21;
  2298.       l_0 = 0;
  2299.       [lFunctionMin setIntValue:l_0+1 at:0];
  2300.       l_m = solnhunk.lmax-1;
  2301.     [lFunctionMax setIntValue:l_m+1 at:0];
  2302.     }
  2303.   
  2304.   }
  2305.   else{
  2306.     j_0 = [jGridMin intValueAt:0] - 1;
  2307.     j_i = [jGridInc intValueAt:0];
  2308.     j_m = [jGridMax intValueAt:0] - 1;
  2309.  
  2310.     k_0 = [kGridMin intValueAt:0] - 1;
  2311.     k_i = [kGridInc intValueAt:0];
  2312.     k_m = [kGridMax intValueAt:0] - 1;
  2313.  
  2314.     l_0 = [lGridMin intValueAt:0] - 1;
  2315.     l_i = [lGridInc intValueAt:0];
  2316.     l_m = [lGridMax intValueAt:0] - 1;
  2317.  
  2318.   /* failsafe, j or k can never be <=0 || >= max*/
  2319.     if(j_i <= 0 || j_i > solnhunk.jmax){
  2320.       NXBeep();  beepError = 21;
  2321.       j_i = 1;
  2322.       [jGridInc setIntValue:j_i at:0];
  2323.     }
  2324.     if(j_0 < 0 || j_0 > solnhunk.jmax-1){
  2325.       NXBeep();  beepError = 21;
  2326.       j_0 = 0;
  2327.       [jGridMin setIntValue:j_0+1 at:0];
  2328.     }
  2329.     if(j_m < 0 || j_m > solnhunk.jmax-1){
  2330.       NXBeep();  beepError = 21;
  2331.       j_m = solnhunk.jmax-1;
  2332.       [jGridMax setIntValue:j_m+1 at:0];
  2333.     }
  2334.     if(j_m < j_0 && planeChoice != 0){
  2335.       NXBeep();  beepError = 21;
  2336.       j_0 = 0;
  2337.       [jGridMin setIntValue:j_0+1 at:0];
  2338.       j_m = solnhunk.jmax-1;
  2339.       [jGridMax setIntValue:j_m+1 at:0];
  2340.     }
  2341.     
  2342.     if(k_i <= 0 || k_i > solnhunk.kmax){
  2343.       NXBeep();  beepError = 21;
  2344.       k_i = 1;
  2345.       [kGridInc setIntValue:k_i at:0];
  2346.     }
  2347.     if(k_0 < 0 || k_0 > solnhunk.kmax-1){
  2348.       NXBeep();  beepError = 21;
  2349.       k_0 = 0;
  2350.       [kGridMin setIntValue:k_0+1 at:0];
  2351.     }
  2352.     if(k_m < 0 || k_m > solnhunk.kmax-1){
  2353.       NXBeep();  beepError = 21;
  2354.       k_m = solnhunk.kmax-1;
  2355.       [kGridMax setIntValue:k_m+1 at:0];
  2356.     }
  2357.     if(k_m < k_0 && planeChoice != 1){
  2358.       NXBeep();  beepError = 21;
  2359.       k_0 = 0;
  2360.       [kGridMin setIntValue:k_0+1 at:0];
  2361.       k_m = solnhunk.kmax-1;
  2362.       [kGridMax setIntValue:k_m+1 at:0];
  2363.     }
  2364.     
  2365.     if(l_i <= 0 || l_i > solnhunk.lmax){
  2366.       NXBeep();  beepError = 21;
  2367.       l_i = 1;
  2368.       [lGridInc setIntValue:l_i at:0];
  2369.     }
  2370.     if(l_0 < 0 || l_0 > solnhunk.lmax-1){
  2371.       NXBeep();  beepError = 21;
  2372.       l_0 = 0;
  2373.       [lGridMin setIntValue:l_0+1 at:0];
  2374.     }
  2375.     if(l_m < 0 || l_m > solnhunk.lmax-1){
  2376.       NXBeep();  beepError = 21;
  2377.       l_m = solnhunk.lmax-1;
  2378.       [lGridMax setIntValue:l_m+1 at:0];
  2379.     }
  2380.     if(l_m < l_0 && planeChoice != 2){
  2381.       NXBeep();  beepError = 21;
  2382.       l_0 = 0;
  2383.       [lGridMin setIntValue:l_0+1 at:0];
  2384.       l_m = solnhunk.lmax-1;
  2385.     [lGridMax setIntValue:l_m+1 at:0];
  2386.     }
  2387.   
  2388.   }
  2389.  
  2390.   switch(planeChoice){
  2391.  
  2392.   case 0:
  2393.     jdim = (k_m - k_0)/k_i + 1;
  2394.     kdim = (l_m - l_0)/l_i + 1;
  2395.     j_m = j_0;
  2396.     [jFunctionMax setIntValue:j_m+1 at:0];
  2397.     j_i = 1;
  2398.     [jFunctionInc setIntValue:j_i at:0];
  2399.     break;
  2400.   case 1:
  2401.     jdim = (j_m - j_0)/j_i + 1;
  2402.     kdim = (l_m - l_0)/l_i + 1;
  2403.     k_m = k_0;
  2404.     [kFunctionMax setIntValue:k_m+1 at:0];
  2405.     k_i = 1;
  2406.     [kFunctionInc setIntValue:k_i at:0];
  2407.     break;
  2408.   case 2:
  2409.     jdim = (j_m - j_0)/j_i + 1;
  2410.     kdim = (k_m - k_0)/k_i + 1;
  2411.     l_m = l_0;
  2412.     [lFunctionMax setIntValue:l_m+1 at:0];
  2413.     l_i = 1;
  2414.     [lFunctionInc setIntValue:l_i at:0];
  2415.     break;
  2416.   }
  2417.  
  2418.   free((void *)functionH.x);
  2419.   free((void *)functionH.y);
  2420.  
  2421.   functionH.jmax = jdim;
  2422.   functionH.kmax = kdim;
  2423.   functionH.x =  (NXCoord *)malloc(jdim*kdim*sizeof(float));
  2424.   functionH.y =  (NXCoord *)malloc(jdim*kdim*sizeof(float));
  2425.  
  2426.  
  2427.   /* load up subset function grid for plotting */
  2428.   
  2429.   /*  load up grid */
  2430.   switch(viewChoice){
  2431.  
  2432.   case 0:
  2433.     ii = 0;
  2434.     for (l = l_0; l <= l_m; l= l + l_i){
  2435.       for (k = k_0; k <= k_m; k= k + k_i){
  2436.     for (j = j_0; j <= j_m; j = j + j_i){
  2437.       i = l*jmax*kmax + k*jmax + j;
  2438.       functionH.x[ii] = gridhunk.x[i];
  2439.       functionH.y[ii] = gridhunk.y[i];
  2440.       ii = ii+1;
  2441.     }
  2442.       }
  2443.     }
  2444.     break;
  2445.  
  2446.   case 1:
  2447.  
  2448.     ii = 0;
  2449.     for (l = l_0; l <= l_m; l= l + l_i){
  2450.       for (k = k_0; k <= k_m; k= k + k_i){
  2451.     for (j = j_0; j <= j_m; j = j + j_i){
  2452.       i = l*jmax*kmax + k*jmax + j;
  2453.       functionH.x[ii] = gridhunk.x[i];
  2454.       functionH.y[ii] = gridhunk.z[i];
  2455.       ii = ii+1;
  2456.     }
  2457.       }
  2458.     }
  2459.     break;
  2460.  
  2461.   case 2:
  2462.  
  2463.     ii = 0;
  2464.     for (l = l_0; l <= l_m; l= l + l_i){
  2465.       for (k = k_0; k <= k_m; k= k + k_i){
  2466.     for (j = j_0; j <= j_m; j = j + j_i){
  2467.       i = l*jmax*kmax + k*jmax + j;
  2468.       functionH.x[ii] = gridhunk.y[i];
  2469.       functionH.y[ii] = gridhunk.z[i];
  2470.       ii = ii+1;
  2471.     }
  2472.       }
  2473.     }
  2474.     break;
  2475.  
  2476.   case 3:
  2477.  
  2478.     ii = 0;
  2479.     for (l = l_0; l <= l_m; l= l + l_i){
  2480.       for (k = k_0; k <= k_m; k= k + k_i){
  2481.     for (j = j_0; j <= j_m; j = j + j_i){
  2482.       switch(planeChoice){
  2483.       case 2:
  2484.         functionH.x[ii] = (float)j+1;
  2485.         functionH.y[ii] = (float)k+1;
  2486.         break;
  2487.       case 0:
  2488.         functionH.x[ii] = (float)k+1;
  2489.         functionH.y[ii] = (float)l+1;
  2490.         break;
  2491.       case 1:
  2492.         functionH.x[ii] = (float)j+1;
  2493.         functionH.y[ii] = (float)l+1;
  2494.         break;
  2495.       }
  2496.       ii = ii+1;
  2497.     }
  2498.       }
  2499.     }
  2500.     break;
  2501.  
  2502.   case 4:
  2503.     ii = 0;
  2504.     for (l = l_0; l <= l_m; l= l + l_i){
  2505.       for (k = k_0; k <= k_m; k= k + k_i){
  2506.     for (j = j_0; j <= j_m; j = j + j_i){
  2507.       i = l*jmax*kmax + k*jmax + j;
  2508.       functionH.x[ii] = gridhunk.y[i];
  2509.       functionH.y[ii] = gridhunk.x[i];
  2510.       ii = ii+1;
  2511.     }
  2512.       }
  2513.     }
  2514.     break;
  2515.  
  2516.   case 5:
  2517.  
  2518.     ii = 0;
  2519.     for (l = l_0; l <= l_m; l= l + l_i){
  2520.       for (k = k_0; k <= k_m; k= k + k_i){
  2521.     for (j = j_0; j <= j_m; j = j + j_i){
  2522.       i = l*jmax*kmax + k*jmax + j;
  2523.       functionH.x[ii] = gridhunk.z[i];
  2524.       functionH.y[ii] = gridhunk.x[i];
  2525.       ii = ii+1;
  2526.     }
  2527.       }
  2528.     }
  2529.     break;
  2530.  
  2531.   case 6:
  2532.  
  2533.     ii = 0;
  2534.     for (l = l_0; l <= l_m; l= l + l_i){
  2535.       for (k = k_0; k <= k_m; k= k + k_i){
  2536.     for (j = j_0; j <= j_m; j = j + j_i){
  2537.       i = l*jmax*kmax + k*jmax + j;
  2538.       functionH.x[ii] = gridhunk.z[i];
  2539.       functionH.y[ii] = gridhunk.y[i];
  2540.       ii = ii+1;
  2541.     }
  2542.       }
  2543.     }
  2544.     break;
  2545.   }
  2546.  
  2547.  
  2548.   [self findFunctionGridMinAndMax];
  2549. /////  if(stateChangeFunction)[self resetFunctionGridMinMax:self];
  2550.   return self;
  2551. }
  2552.  
  2553. - whyTheBeep:sender
  2554. {
  2555.   switch(beepError){
  2556.   case 0:
  2557.     NXRunAlertPanel("The Beep Panel", 
  2558.       "BEEP BEEP, We All Need Some Info Sometime\n Just Click Why The Beep? whenever you hear BEEP\n                A Service Of NeXTcontour",
  2559.             "OK",NULL,NULL);
  2560.     break;
  2561.   case 1:
  2562.     NXRunAlertPanel("The Beep Happened Because", 
  2563.             "Can't animate without drawing function",
  2564.             "OK",NULL,NULL);
  2565.     break;
  2566.   case 2:
  2567.     NXRunAlertPanel("The Beep Happened Because", 
  2568.             "No grid available for plotting \n read in a Grid File",
  2569.             "OK",NULL,NULL);
  2570.     break;
  2571.   case 3:
  2572.     NXRunAlertPanel("The Beep Happened Because", 
  2573.         "No function available for plotting \n read in a Data File",
  2574.             "OK",NULL,NULL);
  2575.     break;
  2576.   case 4:
  2577.     NXRunAlertPanel("The Beep Happened Because", 
  2578.             "You Can't Plot With min = max \n Check min/max Subsets, Plane and Projection",
  2579.             "OK",NULL,NULL);
  2580.     break;
  2581.   case 11:
  2582.     NXRunAlertPanel("The Beep Happened Because", 
  2583.         "Viewing Choice Must Be XY or YX for 2D Cases \n I Fixed It For You",
  2584.             "OK",NULL,NULL);
  2585.     break;
  2586.   case 12:
  2587.     NXRunAlertPanel("The Beep Happened Because", 
  2588.         "Plane Choice Must Be l for 2D Cases \n I Fixed It For You",
  2589.             "OK",NULL,NULL);
  2590.     break;
  2591.   case 13:
  2592.     NXRunAlertPanel("The Beep Happened Because", 
  2593.    "Function Choice >  Number of Functions Available \n I Fixed It For You",
  2594.             "OK",NULL,NULL);
  2595.     break;
  2596.   case 14:
  2597.     NXRunAlertPanel("The Beep Happened Because", 
  2598.    "For 2D Cases You Can't Plot W or W-Momentum \n I Fixed It For You",
  2599.             "OK",NULL,NULL);
  2600.     break;
  2601.   case 15:
  2602.     NXRunAlertPanel("The Beep Happened Because", 
  2603.         "Viewing Choice Must Be XY or YX for 2D Cases \n I Fixed It For You",
  2604.             "OK",NULL,NULL);
  2605.     break;
  2606.   case 16:
  2607.     NXRunAlertPanel("The Beep Happened Because", 
  2608.         "Plane Choice Must Be l for 2D Cases \n I Fixed It For You",
  2609.             "OK",NULL,NULL);
  2610.     break;
  2611.   case 17:
  2612.     NXRunAlertPanel("The Beep Happened Because", 
  2613.    "For 2D Cases You Can't Plot W or W-Momentum \n I Fixed It For You",
  2614.             "OK",NULL,NULL);
  2615.     break;
  2616.   case 18:
  2617.     NXRunAlertPanel("The Beep Happened Because", 
  2618.         "Viewing Choice Must Be XY or YX for 2D Cases \n I Fixed It For You",
  2619.             "OK",NULL,NULL);
  2620.     break;
  2621.   case 19:
  2622.     NXRunAlertPanel("The Beep Happened Because", 
  2623.         "Plane Choice Must Be l for 2D Cases \n I Fixed It For You",
  2624.             "OK",NULL,NULL);
  2625.     break;
  2626.   case 20:
  2627.     NXRunAlertPanel("The Beep Happened Because", 
  2628.         "Indices Out Of Range For Grid Subsets\n I Fixed It For You",
  2629.             "OK",NULL,NULL);
  2630.     break;
  2631.   case 21:
  2632.     NXRunAlertPanel("The Beep Happened Because", 
  2633.         "Indices Out Of Range For Function Subsets\n I Fixed It For You",
  2634.             "OK",NULL,NULL);
  2635.     break;
  2636.   case 22:
  2637.     NXRunAlertPanel("The Beep Happened Because", 
  2638.         "You Need To Choose Plot Grid or Plot Function\n GO FOR IT!",
  2639.             "OK",NULL,NULL);
  2640.     break;
  2641.   case 23:
  2642.     NXRunAlertPanel("The Beep Happened Because", 
  2643.    "For 2D Cases You Can't Plot Z Coordnate Data Line\n I Fixed It For You",
  2644.             "OK",NULL,NULL);
  2645.     break;
  2646.   case 24:
  2647.     NXRunAlertPanel("The Beep Happened Because", 
  2648.    "For 2D Cases You Can't Plot l Coordnate Data Line\n I Fixed It For You",
  2649.             "OK",NULL,NULL);
  2650.     break;
  2651.   case 25:
  2652.     NXRunAlertPanel("The Beep Happened Because", 
  2653.    "Color Option Not Allow By Preferences \n Reset Preferences Or Use Black/Gray \n I Reset Line Color For Now",
  2654.             "OK",NULL,NULL);
  2655.     break;
  2656.   case 26:
  2657.     NXRunAlertPanel("The Beep Happened Because", 
  2658.    "You Can not animate with <= zero increment \n I Fixed It For You",
  2659.             "OK",NULL,NULL);
  2660.     break;
  2661.   case 27:
  2662.     NXRunAlertPanel("The Beep Happened Because", 
  2663.    "The number of funtions to be read in was checked \n previous warning panel took care of it for you",
  2664.             "OK",NULL,NULL);
  2665.     break;
  2666.   case 28:
  2667.     NXRunAlertPanel("The Beep Happened Because", 
  2668.    "You asked for an awful lot of list data \n The alert panel took care of it for you",
  2669.             "OK",NULL,NULL);
  2670.     break;
  2671.   }
  2672.   return self;
  2673. }
  2674.  
  2675. - (int)checkMinMax
  2676. { 
  2677.   float xmin = [xyLimits floatValueAt:0];
  2678.   float xmax = [xyLimits floatValueAt:1];
  2679.   float ymin = [xyLimits floatValueAt:2];
  2680.   float ymax = [xyLimits floatValueAt:3];
  2681.   int error = 0;
  2682.  
  2683.   if(xmin == xmax){
  2684.     NXRunAlertPanel
  2685.       ("Min/Max Check", 
  2686.        "Plot Error xmin = xmax : Check min/max \n Subsets, Plane Choice and Projections", 
  2687.        "OK",NULL,NULL);
  2688.     error = 1;
  2689.   }
  2690.   if(ymin == ymax){
  2691.     NXRunAlertPanel
  2692.       ("Min/Max Check", 
  2693.        "Plot Error ymin = ymax : Check min/max \n Subsets, Plane Choice and Projections", 
  2694.        "OK",NULL,NULL);
  2695.     error = 1;
  2696.   }
  2697.  
  2698.   return error;
  2699. }
  2700.  
  2701. - writeOutLineData:sender 
  2702. {
  2703.   int  jdim = solnhunk.jmax;
  2704.   int  jmax = solnhunk.jmax;
  2705.   int  kmax = solnhunk.kmax;
  2706.   int  j, k, l, i, ii, i_minus;
  2707.   int j_0,j_i,j_m,k_0,k_i,k_m,l_0,l_i,l_m;
  2708.   int coordinateChoice = [absissaCoordinate selectedRow];
  2709.   int lineChoice = [chooseLineData selectedRow];
  2710.   int functionChoice = [functionMatrix selectedRow];
  2711.   BOOL b_2D = [self do2D3D];
  2712.   BOOL aero = [self doAeroDynamics];
  2713.   float gamma = 1.4;
  2714.   float xyData_save;
  2715.   int numberofpoints = solnhunk.jmax*solnhunk.kmax*solnhunk.lmax;
  2716.  
  2717.   /* failsafes for 2d/3d multiple vrs single functions*/
  2718.  
  2719.   if(!aero && functionChoice+1 > number_Of_Functions_Read_In ){
  2720.     NXBeep();    beepError = 13;        /* audible alert */
  2721.     functionChoice = 0;
  2722.     [functionMatrix selectCellAt:functionChoice:0];
  2723.   }
  2724.   if(aero){
  2725.     if((number_Of_Functions_Read_In != 4 && b_2D) ||
  2726.        (number_Of_Functions_Read_In != 5 && !b_2D)){
  2727.       if(functionChoice+1 > number_Of_Functions_Read_In ){
  2728.     NXBeep();    beepError = 13;        /* audible alert */
  2729.     functionChoice = 0;
  2730.     [functionMatrix selectCellAt:functionChoice:0];
  2731.       }
  2732.     }
  2733.   }
  2734.  
  2735.   if(b_2D){
  2736.     if((functionChoice == 3 || functionChoice == 10 )
  2737.        && (aero && number_Of_Functions_Read_In == 4)){
  2738.       NXBeep();    beepError = 14;    /* audible alert */
  2739.       functionChoice = 0;
  2740.       [functionMatrix selectCellAt:functionChoice:0];
  2741.     }
  2742.     if(coordinateChoice == 2 ){
  2743.       NXBeep();    beepError = 23;    /* audible alert */
  2744.       coordinateChoice = 0;
  2745.       [absissaCoordinate selectCellAt:coordinateChoice:0];
  2746.     }
  2747.     if(lineChoice == 2 ){
  2748.       NXBeep();    beepError = 24;    /* audible alert */
  2749.       lineChoice = 0;
  2750.       [chooseLineData selectCellAt:lineChoice:0];
  2751.     }
  2752.   }
  2753.  
  2754.  
  2755.   /* shift indices down 1  */
  2756.   j_0 = [jLineMin intValueAt:0] - 1;
  2757.   j_i = [jLineInc intValueAt:0];
  2758.   j_m = [jLineMax intValueAt:0] - 1;
  2759.  
  2760.   k_0 = [kLineMin intValueAt:0] - 1;
  2761.   k_i = [kLineInc intValueAt:0];
  2762.   k_m = [kLineMax intValueAt:0] - 1;
  2763.  
  2764.   l_0 = [lLineMin intValueAt:0] - 1;
  2765.   l_i = [lLineInc intValueAt:0];
  2766.   l_m = [lLineMax intValueAt:0] - 1;
  2767.   
  2768.  
  2769.   /* failsafe, j or k can never be <=0 || >= max*/
  2770.   if(j_i <= 0 || j_i > solnhunk.jmax){
  2771.     NXBeep();  beepError = 21;
  2772.     j_i = 1;
  2773.     [jLineInc setIntValue:j_i at:0];
  2774.   }
  2775.   if(j_0 < 0 || j_0 > solnhunk.jmax-1){
  2776.     NXBeep();  beepError = 21;
  2777.     j_0 = 0;
  2778.     [jLineMin setIntValue:j_0+1 at:0];
  2779.   }
  2780.   if(j_m < 0 || j_m > solnhunk.jmax-1){
  2781.     NXBeep();  beepError = 21;
  2782.     j_m = solnhunk.jmax-1;
  2783.     [jLineMax setIntValue:j_m+1 at:0];
  2784.   }
  2785.   if(j_m < j_0 && lineChoice == 0){
  2786.     NXBeep();  beepError = 21;
  2787.     j_0 = 0;
  2788.     [jLineMin setIntValue:j_0+1 at:0];
  2789.     j_m = solnhunk.jmax-1;
  2790.     [jLineMax setIntValue:j_m+1 at:0];
  2791.   }
  2792.  
  2793.   if(k_i <= 0 || k_i > solnhunk.kmax){
  2794.     NXBeep();  beepError = 21;
  2795.     k_i = 1;
  2796.     [kLineInc setIntValue:k_i at:0];
  2797.   }
  2798.   if(k_0 < 0 || k_0 > solnhunk.kmax-1){
  2799.     NXBeep();  beepError = 21;
  2800.     k_0 = 0;
  2801.     [kLineMin setIntValue:k_0+1 at:0];
  2802.   }
  2803.   if(k_m < 0 || k_m > solnhunk.kmax-1){
  2804.     NXBeep();  beepError = 21;
  2805.     k_m = solnhunk.kmax-1;
  2806.     [kLineMax setIntValue:k_m+1 at:0];
  2807.   }
  2808.   if(k_m < k_0 && lineChoice == 1){
  2809.     NXBeep();  beepError = 21;
  2810.     k_0 = 0;
  2811.     [kLineMin setIntValue:k_0+1 at:0];
  2812.     k_m = solnhunk.kmax-1;
  2813.     [kLineMax setIntValue:k_m+1 at:0];
  2814.   }
  2815.   
  2816.   if(l_i <= 0 || l_i > solnhunk.lmax){
  2817.     NXBeep();  beepError = 21;
  2818.     l_i = 1;
  2819.     [lLineInc setIntValue:l_i at:0];
  2820.   }
  2821.   if(l_0 < 0 || l_0 > solnhunk.lmax-1){
  2822.     NXBeep();  beepError = 21;
  2823.     l_0 = 0;
  2824.     [lLineMin setIntValue:l_0+1 at:0];
  2825.   }
  2826.   if(l_m < 0 || l_m > solnhunk.lmax-1){
  2827.     NXBeep();  beepError = 21;
  2828.     l_m = solnhunk.lmax-1;
  2829.     [lLineMax setIntValue:l_m+1 at:0];
  2830.   }
  2831.   if(l_m < l_0 && lineChoice == 2){
  2832.     NXBeep();  beepError = 21;
  2833.     l_0 = 0;
  2834.     [lLineMin setIntValue:l_0+1 at:0];
  2835.     l_m = solnhunk.lmax-1;
  2836.     [lLineMax setIntValue:l_m+1 at:0];
  2837.   }
  2838.  
  2839.  
  2840.   switch(lineChoice){
  2841.  
  2842.   case 0:
  2843.     jdim = (j_m - j_0)/j_i + 1;
  2844.     k_m = k_0;
  2845.     l_m = l_0;
  2846.     k_i = 1;
  2847.     l_i = 1;
  2848.     [kLineMax setIntValue:k_m+1 at:0];
  2849.     [lLineMax setIntValue:l_m+1 at:0];
  2850.     [kLineInc setIntValue:k_i at:0];
  2851.     [lLineInc setIntValue:l_i at:0];
  2852.     break;
  2853.   case 1:
  2854.     jdim = (k_m - k_0)/k_i + 1;
  2855.     j_m = j_0;
  2856.     l_m = l_0;
  2857.     j_i = 1;
  2858.     l_i = 1;
  2859.     [jLineMax setIntValue:j_m+1 at:0];
  2860.     [lLineMax setIntValue:l_m+1 at:0];
  2861.     [jLineInc setIntValue:j_i at:0];
  2862.     [lLineInc setIntValue:l_i at:0];
  2863.     break;
  2864.   case 2:
  2865.     jdim = (l_m - l_0)/l_i + 1;
  2866.     k_m = k_0;
  2867.     j_m = j_0;
  2868.     k_i = 1;
  2869.     j_i = 1;
  2870.     [kLineMax setIntValue:k_m+1 at:0];
  2871.     [jLineMax setIntValue:j_m+1 at:0];
  2872.     [kLineInc setIntValue:k_i at:0];
  2873.     [jLineInc setIntValue:j_i at:0];
  2874.     break;
  2875.   }
  2876.  
  2877.   free((void *)xyData.f);
  2878.   free((void *)xyData.x);
  2879.  
  2880.   xyData.jmax = jdim;
  2881.  
  2882.   xyData.x =  (NXCoord *)malloc(jdim*sizeof(float));
  2883.   xyData.f =  (NXCoord *)malloc(jdim*sizeof(float));
  2884.  
  2885.   if(coordinateChoice == 3){
  2886.     ii = 0;
  2887.     xyData_save = 0.0;
  2888.     i_minus = l_0*jmax*kmax + k_0*jmax + j_0;
  2889.     
  2890.     for (l = l_0; l <= l_m; l= l + l_i){
  2891.       for (k = k_0; k <= k_m; k= k + k_i){
  2892.     for (j = j_0; j <= j_m; j = j + j_i){
  2893.       i = l*jmax*kmax + k*jmax + j;
  2894.       if(b_2D){
  2895.         xyData.x[ii] = xyData_save + 
  2896.           sqrt(
  2897.            (gridhunk.x[i]-gridhunk.x[i_minus])*
  2898.            (gridhunk.x[i]-gridhunk.x[i_minus]) +
  2899.            (gridhunk.y[i]-gridhunk.y[i_minus])*
  2900.            (gridhunk.y[i]-gridhunk.y[i_minus]) );
  2901.       }
  2902.       if(!b_2D){
  2903.         xyData.x[ii] = xyData_save + 
  2904.           sqrt(
  2905.            (gridhunk.x[i]-gridhunk.x[i_minus])*
  2906.            (gridhunk.x[i]-gridhunk.x[i_minus]) +
  2907.            (gridhunk.y[i]-gridhunk.y[i_minus])*
  2908.            (gridhunk.y[i]-gridhunk.y[i_minus]) +
  2909.            (gridhunk.z[i]-gridhunk.z[i_minus])*
  2910.            (gridhunk.z[i]-gridhunk.z[i_minus]) );
  2911.       }
  2912.       i_minus = i;
  2913.       xyData_save = xyData.x[ii];
  2914.       ii = ii+1;
  2915.     }
  2916.       }
  2917.     }
  2918.   }
  2919.  
  2920.   ii = 0;
  2921.   for (l = l_0; l <= l_m; l= l + l_i){
  2922.     for (k = k_0; k <= k_m; k= k + k_i){
  2923.       for (j = j_0; j <= j_m; j = j + j_i){
  2924.     i = l*jmax*kmax + k*jmax + j;
  2925.  
  2926.     switch(coordinateChoice){
  2927.     case 0:
  2928.       xyData.x[ii] = gridhunk.x[i];
  2929.       break;
  2930.     case 1:
  2931.       xyData.x[ii] = gridhunk.y[i];
  2932.       break;
  2933.     case 2:
  2934.       xyData.x[ii] = gridhunk.z[i];
  2935.       break;
  2936.     case 3:
  2937.       break;
  2938.     case 4:
  2939.       if(lineChoice==0)xyData.x[ii] = j+1;
  2940.       if(lineChoice==1)xyData.x[ii] = k+1;
  2941.       if(lineChoice==2)xyData.x[ii] = l+1;
  2942.       break;
  2943.     }
  2944.  
  2945.     if(aero){
  2946.       switch(functionChoice){
  2947.       case 0:
  2948.         xyData.f[ii] = solnhunk.functions[i];
  2949.         break;
  2950.       case 1:
  2951.         xyData.f[ii] = solnhunk.functions[i+numberofpoints];
  2952.         break;
  2953.       case 2:
  2954.         xyData.f[ii] = solnhunk.functions[i+2*numberofpoints];
  2955.         break;
  2956.       case 3:
  2957.         xyData.f[ii] = solnhunk.functions[i+3*numberofpoints];
  2958.         break;
  2959.       case 4:
  2960.         if(!b_2D)xyData.f[ii] = solnhunk.functions[i+4*numberofpoints];
  2961.         if(b_2D)xyData.f[ii] = solnhunk.functions[i+3*numberofpoints];
  2962.         break;
  2963.       case 5:
  2964.         xyData.f[ii] = solnhunk.mach_number[i];
  2965.         break;
  2966.       case 6:
  2967.         xyData.f[ii] = solnhunk.pressure[i];
  2968.         break;
  2969.       case 7:
  2970.         xyData.f[ii] =
  2971.           2.0/(gamma*solnhunk.fsmach*solnhunk.fsmach) * 
  2972.         (solnhunk.pressure[i]*gamma - 1.);
  2973.         break;
  2974.       case 8:
  2975.         xyData.f[ii] = 
  2976.           solnhunk.functions[i+numberofpoints]/solnhunk.functions[i];
  2977.         break;
  2978.       case 9:
  2979.         xyData.f[ii] = 
  2980.           solnhunk.functions[i+2*numberofpoints]/solnhunk.functions[i];
  2981.         break;
  2982.       case 10:
  2983.         xyData.f[ii] = 
  2984.           solnhunk.functions[i+3*numberofpoints]/solnhunk.functions[i];
  2985.         break;
  2986.       }
  2987.     }
  2988.  
  2989.     if(!aero){
  2990.       xyData.f[ii] = 
  2991.         solnhunk.functions[i + functionChoice*numberofpoints];
  2992.     }
  2993.  
  2994.     ii = ii+1;
  2995.       }
  2996.     }
  2997.   }
  2998.  
  2999.   return self;
  3000. }
  3001.  
  3002. - (BOOL)appAcceptsAnotherFile:sender
  3003. /* Added by J. Gregory 9-Oct-91. */
  3004. {
  3005.     return YES;
  3006. }
  3007.  
  3008. - (int)app:sender openFile:(const char *)fullPath type:(const char *)aType
  3009. {
  3010.   if(gridIsReadIn && solutionIsReadIn)
  3011.     {gridIsReadIn = NO; solutionIsReadIn = NO;}
  3012.  
  3013.   if(!gridIsReadIn){
  3014.     [self openGridFile:(char *)fullPath];}
  3015.   else{
  3016.     [self openSolnFile:(char *)fullPath];}
  3017.     
  3018.   return YES;
  3019. }
  3020. /*
  3021.  * This function is called by the PlotView object during zooming.
  3022.  */
  3023. - stackOldMinMax:(float)xmin :(float)xmax :(float)ymin :(float)ymax
  3024. {
  3025.   oldMin = currentMin;        /* structure assignment */
  3026.   oldMax = currentMax;
  3027.   currentMin.x = xmin;
  3028.   currentMax.x = xmax;
  3029.   currentMin.y = ymin;
  3030.   currentMax.y = ymax;
  3031.   return self;
  3032. }
  3033.  
  3034. - previousView:sender
  3035. {
  3036.   NXPoint tmp;
  3037.  
  3038.   [self resetXmin:oldMin.x];
  3039.   [self resetXmax:oldMax.x];
  3040.   [self resetYmin:oldMin.y];
  3041.   [self resetYmax:oldMax.y];
  3042.   tmp        = oldMin;
  3043.   oldMin     = currentMin;
  3044.   currentMin = tmp;
  3045.   tmp        = oldMax;
  3046.   oldMax     = currentMax;
  3047.   currentMax = tmp;
  3048.   [self drawPlotButton:1];    /* display "Plotting" */
  3049.   [canvas display];
  3050.   [self drawPlotButton:0];    /* display "Plot" */
  3051.  
  3052.   return self;
  3053. }
  3054.  
  3055. // newTextView: is invoked in response to a new empty window request. It
  3056. // creates a new window containing a TextView. Note that we want new windows 
  3057. // to be offset from each other by some amount; hence the use of Rect.
  3058.  
  3059. #define g_ORIGX 150.0
  3060. #define g_ORIGY 200.0
  3061. static NXRect gRect = {{g_ORIGX, g_ORIGY},{900.0,600.0}};
  3062.  
  3063. - listGridData:sender
  3064. {   
  3065.   char data[64];
  3066.   const char *types[1];
  3067.   int length, max_length;
  3068.   char *s_data;
  3069.   static int window_number = 0;
  3070.  
  3071.   id newTextView;
  3072.  
  3073.   NXOffsetRect(&gRect, 20.0, -20.0);
  3074.   if (gRect.origin.y < 0) {
  3075.     gRect.origin.y = g_ORIGY;
  3076.     gRect.origin.x = g_ORIGX;
  3077.   }
  3078.   newTextView = [[TextView alloc] initFrame:&gRect];
  3079.   [[newTextView window] setDelegate:self];     
  3080.   window_number  = window_number + 1;
  3081.   sprintf(data, " Grid Data %d",window_number);
  3082.   [[newTextView window] setTitle:data];     
  3083.  
  3084.   theTextView = newTextView;
  3085.  
  3086.   pboardoutput = [Pasteboard new]; /* get the standard selection pasteboard */
  3087.  
  3088.   types[0] = NXAsciiPboardType;
  3089.   [pboardoutput declareTypes:types num:1 owner:NULL];
  3090.  
  3091.   sprintf(data, " Grid Data Output \n");
  3092.   [pboardoutput writeType:types[0] data:data length:strlen(data)+1];
  3093.   [[theTextView provideTextObject] paste:self];
  3094.   sprintf(data, " ---------------- \n");
  3095.   [pboardoutput writeType:types[0] data:data length:strlen(data)+1];
  3096.   [[theTextView provideTextObject] paste:self];
  3097.  
  3098.   data_stream = NXOpenMemory(NULL,0,NX_WRITEONLY);
  3099.  
  3100.   listGrid_Data = YES;
  3101.   [self listGridLoad:self];
  3102.   if(!listGrid_Data){
  3103.     [[newTextView window] close];     
  3104.     return self;
  3105.   }
  3106.   listGrid_Data = NO;
  3107.  
  3108.   NXGetMemoryBuffer(data_stream, &s_data, &length, &max_length);
  3109.  
  3110.   [pboardoutput declareTypes:&NXAsciiPboardType num:1 owner:self];
  3111.   [pboardoutput writeType:NXAsciiPboardType data:s_data length:length];
  3112.   NXCloseMemory(data_stream, NX_TRUNCATEBUFFER);
  3113.  
  3114.   [[theTextView provideTextObject] paste:self];
  3115.  
  3116.   return self;
  3117. }
  3118.  
  3119. #define f_ORIGX 200.0
  3120. #define f_ORIGY 150.0
  3121. static NXRect fRect = {{f_ORIGX, f_ORIGY},{500.0,600.0}};
  3122. - listFunctionData:sender
  3123. {   
  3124.   char data[64];
  3125.   const char *types[1];
  3126.   int length, max_length;
  3127.   char *s_data;
  3128.   static int window_number = 0;
  3129.   id newTextView;
  3130.  
  3131.   NXOffsetRect(&fRect, 20.0, -20.0);
  3132.   if (fRect.origin.y < 0) {
  3133.     fRect.origin.y = f_ORIGY;
  3134.     fRect.origin.x = f_ORIGX;
  3135.   }
  3136.   newTextView = [[TextView alloc] initFrame:&fRect];
  3137.   [[newTextView window] setDelegate:self];     
  3138.   window_number  = window_number + 1;
  3139.   sprintf(data, " Function Data %d",window_number);
  3140.   [[newTextView window] setTitle:data];     
  3141. //  [[newTextView window] setTitle:"FUNCTION"];     
  3142.  
  3143.   theTextView = newTextView;
  3144.  
  3145.   pboardoutput = [Pasteboard new]; /* get the standard selection pasteboard */
  3146.  
  3147.   types[0] = NXAsciiPboardType;
  3148.   [pboardoutput declareTypes:types num:1 owner:NULL];
  3149.  
  3150.   sprintf(data, " Function Data Output \n");
  3151.   [pboardoutput writeType:types[0] data:data length:strlen(data)+1];
  3152.   [[theTextView provideTextObject] paste:self];
  3153.   sprintf(data, " ---------------- \n");
  3154.   [pboardoutput writeType:types[0] data:data length:strlen(data)+1];
  3155.   [[theTextView provideTextObject] paste:self];
  3156.  
  3157.   data_stream = NXOpenMemory(NULL,0,NX_WRITEONLY);
  3158.  
  3159.   listSolution_Data = NO;
  3160.   listFunction_Data = YES;
  3161.   [self listFunction_SolutionLoad:self];
  3162.   // ask the text object to do a paste operation
  3163.   if(!listFunction_Data){
  3164.     [[newTextView window] close];     
  3165.     return self;
  3166.   }
  3167.   listFunction_Data = NO;
  3168.  
  3169.   NXGetMemoryBuffer(data_stream, &s_data, &length, &max_length);
  3170.  
  3171.   [pboardoutput declareTypes:&NXAsciiPboardType num:1 owner:self];
  3172.   [pboardoutput writeType:NXAsciiPboardType data:s_data length:length];
  3173.   NXCloseMemory(data_stream, NX_TRUNCATEBUFFER);
  3174.  
  3175.   [[theTextView provideTextObject] paste:self];
  3176.  
  3177.   return self;
  3178. }
  3179.  
  3180. #define s_ORIGX 100.0
  3181. #define s_ORIGY 100.0
  3182. static NXRect sRect = {{s_ORIGX, s_ORIGY},{1000.0,600.0}};
  3183. - listSolutionData:sender
  3184. {   
  3185.   char data[64];
  3186.   const char *types[1];
  3187.   int length, max_length;
  3188.   char *s_data;
  3189.   static int window_number = 0;
  3190.  
  3191.   id newTextView;
  3192.  
  3193.   NXOffsetRect(&sRect, 20.0, -20.0);
  3194.   if (sRect.origin.y < 0) {
  3195.     sRect.origin.y = s_ORIGY;
  3196.     sRect.origin.x = s_ORIGX;
  3197.   }
  3198.   newTextView = [[TextView alloc] initFrame:&sRect];
  3199.   [[newTextView window] setDelegate:self];     
  3200.   window_number  = window_number + 1;
  3201.   sprintf(data, " Solution Data %d",window_number);
  3202.   [[newTextView window] setTitle:data];     
  3203. //  [[newTextView window] setTitle:"SOLUTION"];     
  3204.  
  3205.   theTextView = newTextView;
  3206.  
  3207.   pboardoutput = [Pasteboard new]; /* get the standard selection pasteboard */
  3208.  
  3209.   types[0] = NXAsciiPboardType;
  3210.   [pboardoutput declareTypes:types num:1 owner:NULL];
  3211.  
  3212.   sprintf(data, " Solution Data Output \n");
  3213.   [pboardoutput writeType:types[0] data:data length:strlen(data)+1];
  3214.   [[theTextView provideTextObject] paste:self];
  3215.   sprintf(data, " ---------------- \n");
  3216.   [pboardoutput writeType:types[0] data:data length:strlen(data)+1];
  3217.   [[theTextView provideTextObject] paste:self];
  3218.  
  3219.   data_stream = NXOpenMemory(NULL,0,NX_WRITEONLY);
  3220.  
  3221.   listFunction_Data = NO;
  3222.   listSolution_Data = YES;
  3223.   [self listFunction_SolutionLoad:self];
  3224.   // ask the text object to do a paste operation
  3225.   if(!listSolution_Data){
  3226.     [[newTextView window] close];     
  3227.     return self;
  3228.   }
  3229.   listSolution_Data = NO;
  3230.  
  3231.   NXGetMemoryBuffer(data_stream, &s_data, &length, &max_length);
  3232.  
  3233.   [pboardoutput declareTypes:&NXAsciiPboardType num:1 owner:self];
  3234.   [pboardoutput writeType:NXAsciiPboardType data:s_data length:length];
  3235.   NXCloseMemory(data_stream, NX_TRUNCATEBUFFER);
  3236.  
  3237.   [[theTextView provideTextObject] paste:self];
  3238.  
  3239.   return self;
  3240. }
  3241.  
  3242. - listGridLoad:sender
  3243. {
  3244.   int  j, k, l, i, ii;
  3245.   int  jmax = gridhunk.jmax;
  3246.   int  kmax = gridhunk.kmax;
  3247.   int j_0,j_i,j_m,k_0,k_i,k_m,l_0,l_i,l_m;
  3248.   int planeChoice = [chooseGridPlane selectedRow];
  3249.   BOOL b_2D = [self do2D3D];
  3250.   int total_points = 100, errorAlert = 0;
  3251.  
  3252.   /* failsafe for 2d/3d */
  3253.   if(b_2D){
  3254.     if(planeChoice != 2){
  3255.       NXBeep(); beepError = 12;
  3256.       planeChoice = 2;
  3257.       [chooseGridPlane selectCellAt:planeChoice:0];
  3258.     }
  3259.   }
  3260.  
  3261.  
  3262.   /* shift indices down 1  */
  3263.   j_0 = [jGridMin intValueAt:0] - 1;
  3264.   j_i = [jGridInc intValueAt:0];
  3265.   j_m = [jGridMax intValueAt:0] - 1;
  3266.  
  3267.   k_0 = [kGridMin intValueAt:0] - 1;
  3268.   k_i = [kGridInc intValueAt:0];
  3269.   k_m = [kGridMax intValueAt:0] - 1;
  3270.  
  3271.   l_0 = [lGridMin intValueAt:0] - 1;
  3272.   l_i = [lGridInc intValueAt:0];
  3273.   l_m = [lGridMax intValueAt:0] - 1;
  3274.   
  3275.  
  3276.   /* failsafe, j or k can never be <=0 || >= max*/
  3277.   if(j_i <= 0 || j_i > gridhunk.jmax){
  3278.     NXBeep();  beepError = 20;
  3279.     j_i = 1;
  3280.     [jGridInc setIntValue:j_i at:0];
  3281.   }
  3282.   if(j_0 < 0 || j_0 > gridhunk.jmax-1){
  3283.     NXBeep();  beepError = 20;
  3284.     j_0 = 0;
  3285.     [jGridMin setIntValue:j_0+1 at:0];
  3286.   }
  3287.   if(j_m < 0 || j_m > gridhunk.jmax-1){
  3288.     NXBeep();  beepError = 20;
  3289.     j_m = gridhunk.jmax-1;
  3290.     [jGridMax setIntValue:j_m+1 at:0];
  3291.   }
  3292.   if(j_m < j_0 && planeChoice != 0){
  3293.     NXBeep();  beepError = 20;
  3294.     j_0 = 0;
  3295.     [jGridMin setIntValue:j_0+1 at:0];
  3296.     j_m = gridhunk.jmax-1;
  3297.     [jGridMax setIntValue:j_m+1 at:0];
  3298.   }
  3299.   
  3300.   if(k_i <= 0 || k_i > gridhunk.kmax){
  3301.     NXBeep();  beepError = 20;
  3302.     k_i = 1;
  3303.     [kGridInc setIntValue:k_i at:0];
  3304.   }
  3305.   if(k_0 < 0 || k_0 > gridhunk.kmax-1){
  3306.     NXBeep();  beepError = 20;
  3307.     k_0 = 0;
  3308.     [kGridMin setIntValue:k_0+1 at:0];
  3309.   }
  3310.   if(k_m < 0 || k_m > gridhunk.kmax-1){
  3311.     NXBeep();  beepError = 20;
  3312.     k_m = gridhunk.kmax-1;
  3313.     [kGridMax setIntValue:k_m+1 at:0];
  3314.   }
  3315.   if(k_m < k_0 && planeChoice != 1){
  3316.     NXBeep();  beepError = 20;
  3317.     k_0 = 0;
  3318.     [kGridMin setIntValue:k_0+1 at:0];
  3319.     k_m = gridhunk.kmax-1;
  3320.     [kGridMax setIntValue:k_m+1 at:0];
  3321.   }
  3322.   
  3323.   if(l_i <= 0 || l_i > gridhunk.lmax){
  3324.     NXBeep();  beepError = 20;
  3325.     l_i = 1;
  3326.     [lGridInc setIntValue:l_i at:0];
  3327.   }
  3328.   if(l_0 < 0 || l_0 > gridhunk.lmax-1){
  3329.     NXBeep();  beepError = 20;
  3330.     l_0 = 0;
  3331.     [lGridMin setIntValue:l_0+1 at:0];
  3332.   }
  3333.   if(l_m < 0 || l_m > gridhunk.lmax-1){
  3334.     NXBeep();  beepError = 20;
  3335.     l_m = gridhunk.lmax-1;
  3336.     [lGridMax setIntValue:l_m+1 at:0];
  3337.   }
  3338.   if(l_m < l_0 && planeChoice != 2){
  3339.     NXBeep();  beepError = 20;
  3340.     l_0 = 0;
  3341.     [lGridMin setIntValue:l_0+1 at:0];
  3342.     l_m = gridhunk.lmax-1;
  3343.     [lGridMax setIntValue:l_m+1 at:0];
  3344.   }
  3345.  
  3346.   total_points = ((j_m-j_0 + 1)/j_i)*((k_m-k_0 + 1)/k_i)*((l_m-l_0 + 1)/l_i);
  3347.   if(total_points > 100){
  3348.     NXBeep();    beepError = 28;        /* audible alert */
  3349.     errorAlert = 
  3350.       NXRunAlertPanel("The Number of Lines > 100", 
  3351.               "Number of Lines Of Data Exceeds 100 : You Can \n  Abort or Proceed (with possibly a Long Wait)", 
  3352.               "Continue?","ABORT?",NULL);
  3353.     if(errorAlert  == NX_ALERTALTERNATE){ listGrid_Data = NO; return self;}
  3354.   }
  3355.   if(total_points == 0){
  3356.     NXBeep();    beepError = 28;        /* audible alert */
  3357.     errorAlert = 
  3358.       NXRunAlertPanel("The Number of Lines = 0", 
  3359.               "Make Sure Grid Is Available: You Can \n  Abort or Proceed (with possibly a Long Wait)", 
  3360.               "Continue?","ABORT?",NULL);
  3361.     if(errorAlert  == NX_ALERTALTERNATE){ listGrid_Data = NO; return self;}
  3362.   }
  3363.  
  3364.   if(b_2D){
  3365.     ii = 0;
  3366.     for (l = l_0; l <= l_m; l= l + l_i){
  3367.       for (k = k_0; k <= k_m; k= k + k_i){
  3368.     for (j = j_0; j <= j_m; j = j + j_i){
  3369.       if(ii%100==0)
  3370.         NXPrintf(data_stream, 
  3371.              "\n   j    k    l         x               y \n");
  3372.       i = l*jmax*kmax + k*jmax + j;
  3373.       NXPrintf(data_stream, "%4d %4d %4d %16.10f %16.10f \n",
  3374.            j+1,k+1,l+1,gridhunk.x[i],gridhunk.y[i]);
  3375.       ii = ii+1;
  3376.     }
  3377.       }
  3378.     }
  3379.   }
  3380.  
  3381.   if(!b_2D){
  3382.     ii = 0;
  3383.     for (l = l_0; l <= l_m; l= l + l_i){
  3384.       for (k = k_0; k <= k_m; k= k + k_i){
  3385.     for (j = j_0; j <= j_m; j = j + j_i){
  3386.       if(ii%100==0)NXPrintf
  3387.         (data_stream, 
  3388.          "\n   j    k    l         x               y              z\n");
  3389.       i = l*jmax*kmax + k*jmax + j;
  3390.       NXPrintf(data_stream, "%4d %4d %4d %16.10f %16.10f %16.10f\n",
  3391.            j+1,k+1,l+1,gridhunk.x[i],gridhunk.y[i],gridhunk.z[i]);
  3392.       ii = ii+1;
  3393.     }
  3394.       }
  3395.     }
  3396.   }
  3397.  
  3398.   return self;
  3399. }
  3400.  
  3401. - listFunction_SolutionLoad:sender
  3402. {
  3403.   int  j, k, l, i, ii, n;
  3404.   int  jmax = solnhunk.jmax;
  3405.   int  kmax = solnhunk.kmax;
  3406.   int j_0,j_i,j_m,k_0,k_i,k_m,l_0,l_i,l_m;
  3407.   int planeChoice = [chooseFunctionPlane selectedRow];
  3408.   int functionChoice = [functionMatrix selectedRow];
  3409.   BOOL b_2D = [self do2D3D];
  3410.   BOOL aero = [self doAeroDynamics];
  3411.   float gamma = 1.4;
  3412.   int numberofpoints;
  3413.   int total_points = 100, errorAlert = 0;
  3414.   
  3415.   numberofpoints = solnhunk.jmax*solnhunk.kmax*solnhunk.lmax;
  3416.  
  3417.   /* failsafes for 2d/3d multiple vrs single functions*/
  3418.  
  3419.   if(!aero && functionChoice+1 > number_Of_Functions_Read_In ){
  3420.     NXBeep();    beepError = 13;        /* audible alert */
  3421.     functionChoice = 0;
  3422.     [functionMatrix selectCellAt:functionChoice:0];
  3423.   }
  3424.  
  3425.   if(aero){
  3426.     if((number_Of_Functions_Read_In != 4 && b_2D) ||
  3427.        (number_Of_Functions_Read_In != 5 && !b_2D)){
  3428.       if(functionChoice+1 > number_Of_Functions_Read_In ){
  3429.     NXBeep();    beepError = 13;        /* audible alert */
  3430.     functionChoice = 0;
  3431.     [functionMatrix selectCellAt:functionChoice:0];
  3432.       }
  3433.     }
  3434.   }
  3435.  
  3436.   if(b_2D){
  3437.     if((functionChoice == 3 || functionChoice == 10 )
  3438.        && (aero && number_Of_Functions_Read_In == 4)){
  3439.       NXBeep();    beepError = 14;    /* audible alert */
  3440.       functionChoice = 0;
  3441.       [functionMatrix selectCellAt:functionChoice:0];
  3442.     }
  3443.     if(planeChoice != 2){
  3444.       NXBeep(); beepError = 16;
  3445.       planeChoice = 2;
  3446.       [chooseFunctionPlane selectCellAt:planeChoice:0];
  3447.     }
  3448.   }
  3449.  
  3450.  
  3451.   /* shift indices down 1  */
  3452.   j_0 = [jFunctionMin intValueAt:0] - 1;
  3453.   j_i = [jFunctionInc intValueAt:0];
  3454.   j_m = [jFunctionMax intValueAt:0] - 1;
  3455.  
  3456.   k_0 = [kFunctionMin intValueAt:0] - 1;
  3457.   k_i = [kFunctionInc intValueAt:0];
  3458.   k_m = [kFunctionMax intValueAt:0] - 1;
  3459.  
  3460.   l_0 = [lFunctionMin intValueAt:0] - 1;
  3461.   l_i = [lFunctionInc intValueAt:0];
  3462.   l_m = [lFunctionMax intValueAt:0] - 1;
  3463.   
  3464.  
  3465.   /* failsafe, j or k can never be <=0 || >= max*/
  3466.   if(j_i <= 0 || j_i > solnhunk.jmax){
  3467.     NXBeep();  beepError = 21;
  3468.     j_i = 1;
  3469.     [jFunctionInc setIntValue:j_i at:0];
  3470.   }
  3471.   if(j_0 < 0 || j_0 > solnhunk.jmax-1){
  3472.     NXBeep();  beepError = 21;
  3473.     j_0 = 0;
  3474.     [jFunctionMin setIntValue:j_0+1 at:0];
  3475.   }
  3476.   if(j_m < 0 || j_m > solnhunk.jmax-1){
  3477.     NXBeep();  beepError = 21;
  3478.     j_m = solnhunk.jmax-1;
  3479.     [jFunctionMax setIntValue:j_m+1 at:0];
  3480.   }
  3481.   if(j_m < j_0 && planeChoice != 0){
  3482.     NXBeep();  beepError = 21;
  3483.     j_0 = 0;
  3484.     [jFunctionMin setIntValue:j_0+1 at:0];
  3485.     j_m = solnhunk.jmax-1;
  3486.     [jFunctionMax setIntValue:j_m+1 at:0];
  3487.   }
  3488.   
  3489.   if(k_i <= 0 || k_i > solnhunk.kmax){
  3490.     NXBeep();  beepError = 21;
  3491.     k_i = 1;
  3492.     [kFunctionInc setIntValue:k_i at:0];
  3493.   }
  3494.   if(k_0 < 0 || k_0 > solnhunk.kmax-1){
  3495.     NXBeep();  beepError = 21;
  3496.     k_0 = 0;
  3497.     [kFunctionMin setIntValue:k_0+1 at:0];
  3498.   }
  3499.   if(k_m < 0 || k_m > solnhunk.kmax-1){
  3500.     NXBeep();  beepError = 21;
  3501.     k_m = solnhunk.kmax-1;
  3502.     [kFunctionMax setIntValue:k_m+1 at:0];
  3503.   }
  3504.   if(k_m < k_0 && planeChoice != 1){
  3505.     NXBeep();  beepError = 21;
  3506.     k_0 = 0;
  3507.     [kFunctionMin setIntValue:k_0+1 at:0];
  3508.     k_m = solnhunk.kmax-1;
  3509.     [kFunctionMax setIntValue:k_m+1 at:0];
  3510.   }
  3511.   
  3512.   if(l_i <= 0 || l_i > solnhunk.lmax){
  3513.     NXBeep();  beepError = 21;
  3514.     l_i = 1;
  3515.     [lFunctionInc setIntValue:l_i at:0];
  3516.   }
  3517.   if(l_0 < 0 || l_0 > solnhunk.lmax-1){
  3518.     NXBeep();  beepError = 21;
  3519.     l_0 = 0;
  3520.     [lFunctionMin setIntValue:l_0+1 at:0];
  3521.   }
  3522.   if(l_m < 0 || l_m > solnhunk.lmax-1){
  3523.     NXBeep();  beepError = 21;
  3524.     l_m = solnhunk.lmax-1;
  3525.     [lFunctionMax setIntValue:l_m+1 at:0];
  3526.   }
  3527.   if(l_m < l_0 && planeChoice != 2){
  3528.     NXBeep();  beepError = 21;
  3529.     l_0 = 0;
  3530.     [lFunctionMin setIntValue:l_0+1 at:0];
  3531.     l_m = solnhunk.lmax-1;
  3532.     [lFunctionMax setIntValue:l_m+1 at:0];
  3533.   }
  3534.  
  3535.   total_points = ((j_m-j_0 + 1)/j_i)*((k_m-k_0 + 1)/k_i)*((l_m-l_0 + 1)/l_i);
  3536.   if(total_points > 100){
  3537.     NXBeep();    beepError = 28;        /* audible alert */
  3538.     errorAlert = NXRunAlertPanel("The Number of Lines > 100", 
  3539.                  "Number of Lines Of Data Exceeds 100 : You Can \n  Abort or Proceed (with possibly a Long Wait)", 
  3540.                  "Continue?","ABORT?",NULL);
  3541.     if(errorAlert  == NX_ALERTALTERNATE)
  3542.       { listFunction_Data = NO; listSolution_Data = NO; return self;}
  3543.   }
  3544.   if(total_points == 0){
  3545.     NXBeep();    beepError = 28;        /* audible alert */
  3546.     errorAlert = NXRunAlertPanel("The Number of Lines  = 0", 
  3547.                  "Make Sure Data Is Available : You Can \n  Abort or Proceed (with possibly a Long Wait)", 
  3548.                  "Continue?","ABORT?",NULL);
  3549.     if(errorAlert  == NX_ALERTALTERNATE)
  3550.       { listFunction_Data = NO; listSolution_Data = NO; return self;}
  3551.   }
  3552.  
  3553.   if(listFunction_Data){
  3554.  
  3555.     if(aero){
  3556.       switch(functionChoice){
  3557.       case 0:
  3558.     ii = 0;
  3559.     for (l = l_0; l <= l_m; l= l + l_i){
  3560.       for (k = k_0; k <= k_m; k= k + k_i){
  3561.         for (j = j_0; j <= j_m; j = j + j_i){
  3562.           if(ii%100==0)
  3563.         NXPrintf(data_stream, "\n   j    k    l     Density    \n");
  3564.           i = l*jmax*kmax + k*jmax + j;
  3565.           NXPrintf(data_stream, 
  3566.                "%4d %4d %4d %16.10f \n",
  3567.                j+1,k+1,l+1,solnhunk.functions[i]);
  3568.           ii = ii+1;
  3569.         }
  3570.       }
  3571.     }
  3572.     break;
  3573.       case 1:
  3574.     ii = 0;
  3575.     for (l = l_0; l <= l_m; l= l + l_i){
  3576.       for (k = k_0; k <= k_m; k= k + k_i){
  3577.         for (j = j_0; j <= j_m; j = j + j_i){
  3578.           if(ii%100==0)
  3579.         NXPrintf(data_stream, "\n   j    k    l     U Momentum   \n");
  3580.           i = l*jmax*kmax + k*jmax + j;
  3581.           NXPrintf(data_stream, 
  3582.                "%4d %4d %4d %16.10f \n",
  3583.                j+1,k+1,l+1,solnhunk.functions[i+numberofpoints]);
  3584.           ii = ii+1;
  3585.         }
  3586.       }
  3587.     }
  3588.     break;
  3589.       case 2:
  3590.     ii = 0;
  3591.     for (l = l_0; l <= l_m; l= l + l_i){
  3592.       for (k = k_0; k <= k_m; k= k + k_i){
  3593.         for (j = j_0; j <= j_m; j = j + j_i){
  3594.           if(ii%100==0)
  3595.         NXPrintf(data_stream, "\n   j    k    l     V Momentum   \n");
  3596.           i = l*jmax*kmax + k*jmax + j;
  3597.           NXPrintf(data_stream, 
  3598.                "%4d %4d %4d %16.10f \n",
  3599.                j+1,k+1,l+1,solnhunk.functions[i+2*numberofpoints]);
  3600.           ii = ii+1;
  3601.         }
  3602.       }
  3603.     }
  3604.     break;
  3605.       case 3:
  3606.     ii = 0;
  3607.     for (l = l_0; l <= l_m; l= l + l_i){
  3608.       for (k = k_0; k <= k_m; k= k + k_i){
  3609.         for (j = j_0; j <= j_m; j = j + j_i){
  3610.           if(ii%100==0)
  3611.         NXPrintf(data_stream, "\n   j    k    l     W Momentum   \n");
  3612.           i = l*jmax*kmax + k*jmax + j;
  3613.           NXPrintf(data_stream, 
  3614.                "%4d %4d %4d %16.10f \n",
  3615.                j+1,k+1,l+1,solnhunk.functions[i+3*numberofpoints]);
  3616.           ii = ii+1;
  3617.         }
  3618.       }
  3619.     }
  3620.     break;
  3621.       case 4:
  3622.     ii = 0;
  3623.     for (l = l_0; l <= l_m; l= l + l_i){
  3624.       for (k = k_0; k <= k_m; k= k + k_i){
  3625.         for (j = j_0; j <= j_m; j = j + j_i){
  3626.           if(ii%100==0)
  3627.         NXPrintf(data_stream, "\n   j    k    l     Energy   \n");
  3628.           i = l*jmax*kmax + k*jmax + j;
  3629.           if(!b_2D)NXPrintf(data_stream, 
  3630.                "%4d %4d %4d %16.10f \n",
  3631.                j+1,k+1,l+1,solnhunk.functions[i+4*numberofpoints]);
  3632.           if(b_2D)NXPrintf(data_stream, 
  3633.                "%4d %4d %4d %16.10f \n",
  3634.                j+1,k+1,l+1,solnhunk.functions[i+3*numberofpoints]);
  3635.           ii = ii+1;
  3636.         }
  3637.       }
  3638.     }
  3639.     break;
  3640.       case 5:
  3641.     ii = 0;
  3642.     for (l = l_0; l <= l_m; l= l + l_i){
  3643.       for (k = k_0; k <= k_m; k= k + k_i){
  3644.         for (j = j_0; j <= j_m; j = j + j_i){
  3645.           if(ii%100==0)
  3646.         NXPrintf(data_stream, "\n   j    k    l     Mach Number   \n");
  3647.           i = l*jmax*kmax + k*jmax + j;
  3648.           NXPrintf(data_stream, 
  3649.                "%4d %4d %4d %16.10f \n",
  3650.                j+1,k+1,l+1,solnhunk.mach_number[i]);
  3651.           ii = ii+1;
  3652.         }
  3653.       }
  3654.     }
  3655.     break;
  3656.       case 6:
  3657.     ii = 0;
  3658.     for (l = l_0; l <= l_m; l= l + l_i){
  3659.       for (k = k_0; k <= k_m; k= k + k_i){
  3660.         for (j = j_0; j <= j_m; j = j + j_i){
  3661.           if(ii%100==0)
  3662.         NXPrintf(data_stream, "\n   j    k    l     Pressure   \n");
  3663.           i = l*jmax*kmax + k*jmax + j;
  3664.           NXPrintf(data_stream, 
  3665.                "%4d %4d %4d %16.10f \n",
  3666.                j+1,k+1,l+1,solnhunk.pressure[i]);
  3667.           ii = ii+1;
  3668.         }
  3669.       }
  3670.     }
  3671.     break;
  3672.       case 7:
  3673.     ii = 0;
  3674.     for (l = l_0; l <= l_m; l= l + l_i){
  3675.       for (k = k_0; k <= k_m; k= k + k_i){
  3676.         for (j = j_0; j <= j_m; j = j + j_i){
  3677.           if(ii%100==0)
  3678.         NXPrintf(data_stream, "\n   j    k    l     Cp   \n");
  3679.           i = l*jmax*kmax + k*jmax + j;
  3680.           NXPrintf(data_stream, 
  3681.                "%4d %4d %4d %16.10f \n",
  3682.                j+1,k+1,l+1,
  3683.                2.0/(gamma*solnhunk.fsmach*solnhunk.fsmach) * 
  3684.                (solnhunk.pressure[i]*gamma - 1.));
  3685.           ii = ii+1;
  3686.         }
  3687.       }
  3688.     }
  3689.     break;
  3690.       case 8:
  3691.     ii = 0;
  3692.     for (l = l_0; l <= l_m; l= l + l_i){
  3693.       for (k = k_0; k <= k_m; k= k + k_i){
  3694.         for (j = j_0; j <= j_m; j = j + j_i){
  3695.           if(ii%100==0)
  3696.         NXPrintf(data_stream, "\n   j    k    l     U Velocity   \n");
  3697.           i = l*jmax*kmax + k*jmax + j;
  3698.           NXPrintf(data_stream, 
  3699.                "%4d %4d %4d %16.10f \n",
  3700.                j+1,k+1,l+1,
  3701.                solnhunk.functions[i+numberofpoints]/
  3702.                solnhunk.functions[i]);
  3703.           ii = ii+1;
  3704.         }
  3705.       }
  3706.     }
  3707.     break;
  3708.       case 9:
  3709.     ii = 0;
  3710.     for (l = l_0; l <= l_m; l= l + l_i){
  3711.       for (k = k_0; k <= k_m; k= k + k_i){
  3712.         for (j = j_0; j <= j_m; j = j + j_i){
  3713.           if(ii%100==0)
  3714.         NXPrintf(data_stream, "\n   j    k    l     V Velocity   \n");
  3715.           i = l*jmax*kmax + k*jmax + j;
  3716.           NXPrintf(data_stream, 
  3717.                "%4d %4d %4d %16.10f \n",
  3718.                j+1,k+1,l+1,
  3719.                solnhunk.functions[i+2*numberofpoints]
  3720.                /solnhunk.functions[i]);
  3721.           ii = ii+1;
  3722.         }
  3723.       }
  3724.     }
  3725.     break;
  3726.       case 10:
  3727.     ii = 0;
  3728.     for (l = l_0; l <= l_m; l= l + l_i){
  3729.       for (k = k_0; k <= k_m; k= k + k_i){
  3730.         for (j = j_0; j <= j_m; j = j + j_i){
  3731.           if(ii%100==0)
  3732.         NXPrintf(data_stream, "\n   j    k    l     W Velocity   \n");
  3733.           i = l*jmax*kmax + k*jmax + j;
  3734.           NXPrintf(data_stream, 
  3735.                "%4d %4d %4d %16.10f \n",
  3736.                j+1,k+1,l+1,
  3737.                solnhunk.functions[i+3*numberofpoints]/
  3738.                solnhunk.functions[i]);
  3739.           ii = ii+1;
  3740.         }
  3741.       }
  3742.     }
  3743.     break;
  3744.       }
  3745.     }
  3746.     if(!aero){
  3747.       ii = 0;
  3748.       for (l = l_0; l <= l_m; l= l + l_i){
  3749.     for (k = k_0; k <= k_m; k= k + k_i){
  3750.       for (j = j_0; j <= j_m; j = j + j_i){
  3751.           if(ii%100==0)
  3752.         NXPrintf(data_stream, "\n   j    k    l     Function %d \n",
  3753.              functionChoice+1);
  3754.         i = l*jmax*kmax + k*jmax + j;
  3755.         NXPrintf(data_stream, 
  3756.              "%4d %4d %4d %16.10f \n",
  3757.              j+1,k+1,l+1,
  3758.              solnhunk.functions[i+functionChoice*numberofpoints]);
  3759.         ii = ii+1;
  3760.       }
  3761.     }
  3762.       }
  3763.     }
  3764.   }
  3765.  
  3766.   if(listSolution_Data && b_2D && aero){
  3767.     ii = 0;
  3768.     for (l = l_0; l <= l_m; l= l + l_i){
  3769.       for (k = k_0; k <= k_m; k= k + k_i){
  3770.     for (j = j_0; j <= j_m; j = j + j_i){
  3771.       if(ii%100==0)NXPrintf(data_stream, 
  3772.              "\n   j    k    l         Q1               Q2             Q3             Q4\n");
  3773.       i = l*jmax*kmax + k*jmax + j;
  3774.       NXPrintf(data_stream, 
  3775.            "%4d %4d %4d %16.10f %16.10f %16.10f %16.10f\n",
  3776.            j+1,k+1,l+1,
  3777.            solnhunk.functions[i],
  3778.            solnhunk.functions[i+numberofpoints],
  3779.            solnhunk.functions[i+numberofpoints*2],
  3780.            solnhunk.functions[i+numberofpoints*3]);
  3781.       ii = ii+1;
  3782.     }
  3783.       }
  3784.     }
  3785.   }
  3786.  
  3787.   if(listSolution_Data && !b_2D && aero){
  3788.     ii = 0;
  3789.     for (l = l_0; l <= l_m; l= l + l_i){
  3790.       for (k = k_0; k <= k_m; k= k + k_i){
  3791.     for (j = j_0; j <= j_m; j = j + j_i){
  3792.       if(ii%100==0)NXPrintf(data_stream, 
  3793.              "\n   j    k    l         Q1               Q2             Q3             Q4             Q5\n");
  3794.       i = l*jmax*kmax + k*jmax + j;
  3795.       NXPrintf(data_stream, 
  3796.            "%4d %4d %4d %16.10f %16.10f %16.10f %16.10f %16.10f\n",
  3797.            j+1,k+1,l+1,
  3798.            solnhunk.functions[i],
  3799.            solnhunk.functions[i+numberofpoints],
  3800.            solnhunk.functions[i+numberofpoints*2],
  3801.            solnhunk.functions[i+numberofpoints*3],
  3802.            solnhunk.functions[i+numberofpoints*4]);
  3803.       ii = ii+1;
  3804.     }
  3805.       }
  3806.     }
  3807.   }
  3808.   if(listSolution_Data && !aero){
  3809.     ii = 0;
  3810.     for (l = l_0; l <= l_m; l= l + l_i){
  3811.       for (k = k_0; k <= k_m; k= k + k_i){
  3812.     for (j = j_0; j <= j_m; j = j + j_i){
  3813.       if(ii%100==0)NXPrintf(data_stream, 
  3814.              "\n   n    j    k    l  \n");
  3815.       i = l*jmax*kmax + k*jmax + j;      
  3816.       for(n = 0; n < number_Of_Functions_Read_In; n = n+1){
  3817.         NXPrintf(data_stream, 
  3818.              "Q %4d %4d %4d %4d %16.10f \n",
  3819.              n+1, j+1,k+1,l+1,solnhunk.functions[i+numberofpoints*n]);
  3820.       }
  3821.       ii = ii+1;
  3822.     }
  3823.       }
  3824.     }
  3825.   }
  3826.  
  3827.   return self;
  3828. }
  3829.  
  3830. - setWindowSize:sender
  3831. {
  3832.   NXRect fullFrame,currentFrame;
  3833.   
  3834.   NXSetRect(&fullFrame, 114.0, 0.0, 930.0, 830.0);
  3835.  
  3836.   [canvasWindow getFrame:¤tFrame];
  3837.  
  3838.   if(!NXEqualRect(¤tFrame, &fullFrame))[canvasWindow getFrame:&oldFrame];
  3839.  
  3840.   if([chooseScreenSize state])[canvasWindow placeWindow:&fullFrame];
  3841.   if(![chooseScreenSize state])[canvasWindow placeWindow:&oldFrame];
  3842.  
  3843.   [canvasWindow orderFront:self];
  3844.  
  3845.   [self drawPlotButton:1];    /* display "Plotting" */
  3846.   [canvas display];
  3847.   [self drawPlotButton:0];    /* display "Plot" */
  3848.  
  3849.   return self;
  3850. }
  3851.  
  3852. @end
  3853.  
  3854.